public override void DisplayInfo(GameObject gameObject)
{
string nameToDisplay = (cardConfig as GearConfig).GetCardName();
gameObject.GetComponent <Card>().displayName.text = nameToDisplay;
Sprite imageToDisplay = (cardConfig as GearConfig).GetSprite();
gameObject.GetComponent <Card>().displaImage.sprite = imageToDisplay;
string descriptionToDisplay = (cardConfig as GearConfig).GetDescription();
gameObject.GetComponent <Card>().displayDescription.text = descriptionToDisplay;
string abilityToDisplay = (cardConfig as GearConfig).GetUniqueAbility();
gameObject.GetComponent <Card>().displayAbillity.text = abilityToDisplay;
CardClass typeToDisplay = (cardConfig as GearConfig).GetCardClass();
gameObject.GetComponent <Card>().displayType.text = typeToDisplay.ToString();
string classToDisplay = (cardConfig as GearConfig).GetCardType().ToString();
gameObject.GetComponent <Card>().displayClass.text = classToDisplay;
float attackToDisplay = (cardConfig as GearConfig).GetMaxAttack();
gameObject.GetComponent <Card>().SetMaxAttack(attackToDisplay);
float defenceToDisplay = (cardConfig as GearConfig).GetMaxDefence();
gameObject.GetComponent <Card>().SetMaxDefence(defenceToDisplay);
}
private static List <Card> GetRandomDeckFromClass(CardClass heroClass)
{
var allCards = Cards.All.ToList();
for (int i = 0; i < allCards.Count; i++)
{
if (allCards[i].Rarity != Rarity.LEGENDARY)
{
allCards.Add(allCards[i]);
}
}
allCards = Extensions.Shuffle(allCards).ToList();
var toReturn = new List <Card>();
while (toReturn.Count < 30)
{
if (allCards[0].Class == heroClass || allCards[0].Class == CardClass.NEUTRAL)
{
toReturn.Add(allCards[0]);
}
allCards.RemoveAt(0);
}
return(toReturn);
}
private static List <Card> GetRandomStandardDeckFromClass(CardClass heroClass)
{
var allCards = Cards.Standard[heroClass];
List <Card> allCardsD = new List <Card>();
for (int i = 0; i < allCards.Count; i++)
{
if (allCards[i].Rarity != Rarity.LEGENDARY)
{
allCardsD.Add(allCards[i].Clone());
allCardsD.Add(allCards[i].Clone());
}
else
{
allCardsD.Add(allCards[i].Clone());
}
}
allCardsD = Extensions.Shuffle(allCardsD).ToList();
var toReturn = new List <Card>();
while (toReturn.Count < 30)
{
toReturn.Add(allCardsD[0]);
allCardsD.RemoveAt(0);
}
return(toReturn);
}
private List <Card>[] GetClassCard(CardClass heroClass, Func <IEnumerable <Card>, IEnumerable <Card> > filter)
{
Dictionary <CardClass, IEnumerable <Card> > cardSet = Cards.FormatTypeClassCards(Game.FormatType);
IEnumerable <Card> classCards = filter.Invoke(cardSet[heroClass].Where(p => p.Class == heroClass && !p.Tags.ContainsKey(GameTag.QUEST)));
return(new[] { classCards.ToList() });
}
public Deck(DeckType type, string name, CardClass cardClass, IEnumerable <int> cards)
{
Type = type;
Name = name;
Class = cardClass;
Cards = CardSorting.Sort(cards.GroupBy(x => x).Select(x => new Card(x.Key, x.Count())));
}
public void GenerateInventoryItem(InventoryController controller, CardClass card)
{
InventoryController = controller;
Card = card;
ItemName.text = card.CardName;
Sprite img;
switch (card.Type)
{
case CardClass.CardType.ATK:
default:
img = Resources.Load <Sprite>("card_player/attack");
break;
case CardClass.CardType.GOLD:
img = Resources.Load <Sprite>("card_player/money");
break;
case CardClass.CardType.POTION:
img = Resources.Load <Sprite>("card_player/health");
break;
}
CardImage.sprite = img;
CardText.text = "+" + card.Value + (card.Type == CardClass.CardType.GOLD ? "%" : "");
ItemPrice.text = card.Price.ToString();
}
public bool Swap(CardClass newClass)
{
CurrentClass = newClass;
image.color = Color.white;
switch (CurrentClass)
{
case CardClass.KING:
image.sprite = KingSprite;
return(true);
case CardClass.QUEEN:
image.sprite = QueenSprite;
return(true);
case CardClass.NOBLE:
image.sprite = NobleSprite;
return(true);
case CardClass.SOLDIER:
image.sprite = SoldierSprite;
return(true);
case CardClass.ASSASSIN:
image.sprite = AssassinSprite;
return(true);
case CardClass.COMMONER:
image.sprite = CommonSprite;
return(true);
}
CustomConsole.LogWarning("I guess you added a class to the enum but didn't add it to classIcon? Fix that.");
return(false);
}
public Card(CardClass cardClass, CardDice cardDice = CardDice.O, int number = 0, int tripleId = 0)
{
Dice = cardDice;
Class = cardClass;
Number = number;
TripleId = tripleId;
}
/// <summary>
/// Returns a list of each deck's name in this HeroClass
/// </summary>
/// <returns></returns>
static List <string> GetDeckNames(CardClass heroClass)
{
string query = $"select distinct deck_name from AllInfo where hero_class = '{heroClass}';";
var DeckNames = new DataTable();
using (var conn = new SQLiteConnection(connection))
{
conn.Open();
//var cmd = new SQLiteCommand(query, conn);
using (var adapter = new SQLiteDataAdapter {
SelectCommand = new SQLiteCommand(query, conn)
})
{
adapter.Fill(DeckNames);
}
}
var names = new List <string>();
foreach (DataRow row in DeckNames.Rows)
{
names.Add(row.ItemArray[0].ToString());
}
return(names);
}
// Use this for initialization
void Start () {
classpic = transform.FindChild("pic").renderer.material;
switch (name)
{
case "圣骑士": myclass= CardClass.kpaladin;
break;
case "德鲁伊": myclass= CardClass.kdruid;
break;
case "战士": myclass= CardClass.kwarrior;
break;
case "术士": myclass= CardClass.kwarlock;
break;
case "法师": myclass= CardClass.kmage;
break;
case "潜行者": myclass= CardClass.krogue;
break;
case "牧师": myclass= CardClass.kpriest;
break;
case "猎人": myclass= CardClass.khunter;
break;
case "萨满祭司": myclass= CardClass.kshama;
break;
}
}
public void ItemUnSold(CardClass card)
{
ItemSoldList.Remove(card);
SumOfCosts += Mathf.FloorToInt(card.Price * 0.3f);
RevalidateButtonsAndCosts();
}
public Agent(List <Card> cards, CardClass heroClass)
{
var deck = new HSAI.Deck.Deck();
deck.CardList = cards;
deck.HeroClass = heroClass;
}
/// <summary>
/// Returns a prediction of the opponent's deck classes, i.e. set of classes and there probability,
/// based on the board cards of the opponent.
/// </summary>
/// <param name="opponent">the controller of the opponent</param>
/// <param name="boardCards">the board cards of the opponent</param>
/// <returns>a set of classes and there probability</returns>
private Dictionary <CardClass, double> predictDeckClasses(Controller opponent, BoardCards boardCards)
{
int denominator = boardCards.Count;
// fetch all classes of the opponent's board cards
var boardClasses = new List <CardClass>();
boardClasses.AddRange(boardCards.Cards
.Select(c => c.Class)
.ToList());
// add the class of the opponent's hero
CardClass heroClass = opponent.HeroClass;
if (!boardClasses.Contains(heroClass))
{
boardClasses.Add(heroClass);
// increment denominator because the hero is not part of the opponent's board
denominator++;
}
var deckClasses = new Dictionary <CardClass, double>();
boardClasses.GroupBy(c => c)
// calculate card class distribution over all already drawn cards
.Select(c => new KeyValuePair <CardClass, double>(c.Key, ((double)c.Count() / denominator)))
.OrderByDescending(c => c.Key)
.ToList().ForEach(c => deckClasses.Add(c.Key, c.Value));
return(deckClasses);
}
private static string CreateMethode(string name,
IEnumerable <Card> values, bool?collect, CardSet set, CardType type,
CardClass cardClass)
{
string idString = MapCardSetAdventureString(set);
IOrderedEnumerable <Card> valuesOrdered = values
.Where(p => p.Set == set &&
(collect == null || p.Collectible == collect) &&
(type == CardType.INVALID && p.Type != CardType.HERO && p.Type != CardType.HERO_POWER || p.Type == type) &&
(cardClass == CardClass.INVALID || p.Class == cardClass) &&
(idString == String.Empty || Adventure && p.Id.StartsWith(idString) || !Adventure && !p.Id.StartsWith(idString)))
.OrderBy(p => p.Type.ToString());
if (!valuesOrdered.Any())
{
return(null);
}
var str = new StringBuilder();
str.AppendLine($"\t\tprivate static void {name}(IDictionary<string, Power> cards)");
str.AppendLine("\t\t{");
foreach (Card card in valuesOrdered)
{
str.Append(AddCardString(card));
str.Append(AddCardCode(card));
}
str.AppendLine("\t\t}");
return(str.ToString());
}
void MobMove()
{
var(pointToFistStepX, pointToFistStepY) = FindPointToFistStep(
CardClass.GetMapCardsClassFromMapGameObjects(level.Map),
level.PlayerX, level.PlayerY, X, Y);
if (pointToFistStepX == -1 || pointToFistStepY == -1)
{
return;
}
var(dx, dy) = (X - pointToFistStepX, Y - pointToFistStepY);
if (level.Map[X - dx, Y - dy].TryGetComponent(out Player player1) &&
player1.Power > Power)
{
return;
}
if (level.Map[X - dx, Y - dy].TryGetComponent(out Player player))
{
level.PlayerX = level.PlayerY = -1;
Debug.Log("You lose, mf!");
}
Destroy(level.Map[X - dx, Y - dy]);
level.Map[X, Y].GetComponent <Card>().Move(-dx, -dy);
level.Check();
}
public static Deck GetMostPopular(CardClass heroClass)
{
string query = $"select * from AllInfo where num_games = (select max(num_games) from AllInfo where hero_class = '{heroClass.ToString()}');";
var Deck = new DataTable();
using (var conn = new SQLiteConnection(connection))
{
//var cmd = new SQLiteCommand(query, conn);
using (var adapter = new SQLiteDataAdapter {
SelectCommand = new SQLiteCommand(query, conn)
})
{
adapter.Fill(Deck);
}
}
var cards = new List <Card>();
//var col = Deck.Columns[4];
foreach (DataRow row in Deck.Rows)
{
cards.Add(Cards.FromName(row.ItemArray[4].ToString()));
}
Archetype archetype = DeckHelper.Map <Archetype>(Deck.Rows[0].ItemArray[1].ToString());
string deckName = Deck.Rows[0].ItemArray[2].ToString();
int numGames = (int)(long)Deck.Rows[0].ItemArray[3];
return(new Deck(heroClass, archetype, deckName, numGames, cards));
}
//For BuildUnit
public SpecialAP(string _action, CardType _type, CardClass _class, CardClass _classB = CardClass.Other)
{
actionA = _action;
cardType = _type;
classA = _class;
classB = _classB;
}
/// <summary>
/// Returns the specified deck from hearth_decks.db
/// </summary>
/// <param name="deckName"></param>
/// <returns></returns>
public static Deck DeckFromName(string deckName, CardClass heroClass)
{
string query = $"select archetype, num_games, card_name from AllInfo where deck_name = '{deckName}';";
var Deck = new DataTable();
using (var conn = new SQLiteConnection(connection))
{
conn.Open();
//var cmd = new SQLiteCommand(query, conn);
using (var adapter = new SQLiteDataAdapter {
SelectCommand = new SQLiteCommand(query, conn)
})
{
adapter.Fill(Deck);
}
}
var cards = new List <Card>();
//var col = Deck.Columns[4];
foreach (DataRow row in Deck.Rows)
{
cards.Add(Cards.FromName(row.ItemArray[2].ToString()));
}
Archetype archetype = DeckHelper.Map <Archetype>(Deck.Rows[0].ItemArray[0].ToString());
int numGames = (int)(long)Deck.Rows[0].ItemArray[1];
return(new Deck(heroClass, archetype, deckName, numGames, cards));
}
public DistributedSearch(string configFilename)
{
// Grab the configuration info
_configFilename = configFilename;
var config = Toml.ReadFile <Configuration>(_configFilename);
// Console.WriteLine("NumFeatures: " + config.Map.Features.Length);
// foreach (var p in config.Map.Features)
// {
// Console.WriteLine(p.Name);
// }
// Configuration for the search space
_heroClass = CardReader.GetClassFromName(config.Deckspace.HeroClass);
CardSet[] sets = CardReader.GetSetsFromNames(config.Deckspace.CardSets);
_cardSet = CardReader.GetCards(_heroClass, sets);
// Setup the logs to record the data on individuals
InitLogs();
// Set up search algorithm
Console.WriteLine("Algo: " + config.Search.Type);
if (config.Search.Type.Equals("MAP-Elites"))
{
var searchConfig = Toml.ReadFile <MapElitesParams>(config.Search.ConfigFilename);
_searchAlgo = new MapElitesAlgorithm(searchConfig);
}
else if (config.Search.Type.Equals("EvolutionStrategy"))
{
var searchConfig = Toml.ReadFile <EvolutionStrategyParams>(config.Search.ConfigFilename);
_searchAlgo = new EvolutionStrategyAlgorithm(searchConfig);
}
}
public void GenerateShopItem(ShopController shopController, CardClass card, bool isInventoryItem = false)
{
ShopController = shopController;
Card = card;
IsInInventory = isInventoryItem;
TextItemName.text = card.CardName;
Sprite img;
switch (card.Type)
{
case CardClass.CardType.ATK:
default:
img = Resources.Load <Sprite>("card_player/attack");
break;
case CardClass.CardType.GOLD:
img = Resources.Load <Sprite>("card_player/money");
break;
case CardClass.CardType.POTION:
img = Resources.Load <Sprite>("card_player/health");
break;
}
ImageCard.sprite = img;
if (IsInInventory)
{
TextPrice.text = Mathf.FloorToInt(card.Price * 0.3f).ToString();
BuyButtonObject.GetComponentInChildren <Text>().text = "Sell";
}
else
{
TextPrice.text = card.Price.ToString();
BuyButtonObject.GetComponentInChildren <Text>().text = "Add";
}
}
/// <summary>
/// Returns the default hero class card.
/// ex; Returns Grommash for the WARRIOR class.
/// </summary>
/// <param name="cardClass"></param>
/// <returns></returns>
public static Card HeroCard(CardClass cardClass)
{
switch (cardClass)
{
case CardClass.DRUID:
return(AllCards["HERO_06"]);
case CardClass.HUNTER:
return(AllCards["HERO_05"]);
case CardClass.MAGE:
return(AllCards["HERO_08"]);
case CardClass.PALADIN:
return(AllCards["HERO_04"]);
case CardClass.PRIEST:
return(AllCards["HERO_09"]);
case CardClass.ROGUE:
return(AllCards["HERO_03"]);
case CardClass.SHAMAN:
return(AllCards["HERO_02"]);
case CardClass.WARLOCK:
return(AllCards["HERO_07"]);
case CardClass.WARRIOR:
return(AllCards["HERO_01"]);
default:
throw new NotImplementedException();
}
}
public override TaskState Process()
{
if (_opClass)
{
_cardClass = Controller.Opponent.HeroClass;
}
if (_useRandomCard)
{
IReadOnlyList <Card> randCards = RandomCardTask.GetCardList(Source, _cardType, _cardClass, rarity: _rarity);
foreach (IPlayable p in IncludeTask.GetEntities(_type, Controller, Source, Target, Playables))
{
Card pick = Util.Choose(randCards);
Generic.ChangeEntityBlock.Invoke(Controller, p, pick);
//TODO p[GameTag.DISPLAYED_CREATOR] = Source.Id;
}
return(TaskState.COMPLETE);
}
foreach (IPlayable p in IncludeTask.GetEntities(_type, Controller, Source, Target, Playables))
{
Generic.ChangeEntityBlock.Invoke(Controller, p, _card);
// TODO p[GameTag.DISPLAYED_CREATOR] = Source.Id;
}
return(TaskState.COMPLETE);
}
public void OnCreateGame(KettleCreateGame createGame)
{
KettleCreatePlayer player1 = createGame.Players[0];
KettleCreatePlayer player2 = createGame.Players[1];
string hero1 = player1.Hero;
string hero2 = player2.Hero;
CardClass hero1Class = Cards.FromId(hero1).Class;
CardClass hero2Class = Cards.FromId(hero2).Class;
var player1Deck = player1.Cards.Select(Cards.FromId).ToList();
var player2Deck = player2.Cards.Select(Cards.FromId).ToList();
Console.WriteLine("creating game");
Game = new Game(new GameConfig
{
Player1HeroClass = hero1Class,
Player1Deck = player1Deck,
Player2HeroClass = hero2Class,
Player2Deck = player2Deck,
SkipMulligan = false,
});
// Start the game and send the following powerhistory to the client
Game.StartGame();
ShowLog(Game, LogLevel.VERBOSE);
SendPowerHistory(Game.PowerHistory.Last);
SendChoicesOrOptions();
}
public override TaskState Process()
{
switch (_type)
{
case EntityType.HERO:
_cardClass = Controller.HeroClass;
break;
case EntityType.OP_HERO:
_cardClass = Controller.Opponent.HeroClass;
break;
case EntityType.INVALID:
break;
default:
throw new NotImplementedException();
}
IReadOnlyList <Card> cardsList = GetCardList(Source, _cardType, _cardClass, _cardSet, _race, _rarity, _gameTagFilter);
IPlayable randomCard = Entity.FromCard(_opposite ? Controller.Opponent : Controller, Util.Choose(cardsList));
Playables = new List <IPlayable> {
randomCard
};
Game.OnRandomHappened(true);
return(TaskState.COMPLETE);
}
public List <GameObject> GenerateRewardMixPool(CardClass cardClassA, CardClass cardClassB)
{
List <GameObject> rewardCard = new List <GameObject>();
List <GameObject> cardPool = new List <GameObject>();
foreach (GameObject card in cardClassA.AllClassCard)
{
cardPool.Add(card);
}
foreach (GameObject card in cardClassB.AllClassCard)
{
cardPool.Add(card);
}
List <int> cardCode = new List <int>();
while (cardCode.Count < 3)
{
int a = Random.Range(0, cardPool.Count);
if (!cardCode.Contains(a))
{
cardCode.Add(a);
}
}
foreach (int a in cardCode)
{
GameObject card = Instantiate(cardPool[a]);
card.transform.SetParent(RewardWindow.transform);
rewardCard.Add(card);
}
return(rewardCard);
}
//new
public bool CheckResource(int resourceCost, CardClass cardClass, string action, DataType type)
{
for (int i = 0; i < SpecialR_List.Count; i++)
{
if (SpecialR_List[i].isMatched(cardClass, action))
{
resourceCost--;
}
}
int myResource = 0;
if (type == DataType.Ore)
{
myResource = GetTotalOre();
}
if (type == DataType.Food)
{
myResource = GetTotalFood();
}
if (myResource < resourceCost)
{
FeedBackText.Instance.Text = "Don't have enough resources";
return(false);
}
return(true);
}
public static List <Card> GetCards(CardClass heroClass, CardSet[] sets)
{
var hs = new HashSet <Card>();
var cards = new List <Card>();
List <Card> allCards = GetAllCards();
foreach (Card c in allCards)
{
if (c != Cards.FromName("Default") &&
c.Implemented &&
c.Collectible &&
c.Type != CardType.HERO &&
c.Type != CardType.ENCHANTMENT &&
c.Type != CardType.INVALID &&
c.Type != CardType.HERO_POWER &&
c.Type != CardType.TOKEN &&
(c.Class == CardClass.NEUTRAL || c.Class == heroClass) &&
!hs.Contains(c))
{
bool validSet = false;
foreach (CardSet curSet in sets)
{
validSet |= (c.Set == curSet);
}
if (validSet)
{
cards.Add(c);
hs.Add(c);
}
}
}
return(cards);
}
private static string CreateMethodeTest(string name,
IEnumerable <Card> values, bool?collect, CardSet set, CardType type,
CardClass cardClass)
{
string idString = MapCardSetAdventureString(set);
IOrderedEnumerable <Card> valuesOrdered = values.Where(p => p.Set == set &&
(collect == null || p.Collectible == collect) &&
(type == CardType.INVALID && p.Type != CardType.HERO && p.Type != CardType.HERO_POWER || p.Type == type) &&
(cardClass == CardClass.INVALID || p.Class == cardClass) &&
(idString == String.Empty || Adventure && p.Id.StartsWith(idString) || !Adventure && !p.Id.StartsWith(idString)))
.OrderBy(p => p.Type.ToString());
if (!valuesOrdered.Any())
{
return(null);
}
var str = new StringBuilder();
//str.AppendLine("\t[TestClass]");
str.AppendLine($"\tpublic class {name}{UpperCaseFirst(set.ToString())}Test");
str.AppendLine("\t{");
foreach (Card card in valuesOrdered)
{
var cardNameRx = Rgx.Replace(card.Name, "").Split(' ', '-').ToList();
string cardName = String.Join("", cardNameRx.Select(p => UpperCaseFirst(p)).ToList());
CardClass heroClass1 = card.Class == CardClass.INVALID || card.Class == CardClass.NEUTRAL
? CardClass.MAGE
: card.Class;
CardClass heroClass2 = card.Class == CardClass.INVALID || card.Class == CardClass.NEUTRAL
? CardClass.MAGE
: card.Class;
str.Append(AddCardString(card, 1));
str.AppendLine("\t\t[Fact(Skip = \"ignore\")]");
str.AppendLine($"\t\tpublic void {cardName}_{card.Id}()");
str.AppendLine("\t\t{");
str.AppendLine($"\t\t\t// TODO {cardName}_{card.Id} test");
str.AppendLine("\t\t\tvar game = new Game(new GameConfig");
str.AppendLine("\t\t\t{");
str.AppendLine("\t\t\t\tStartPlayer = 1,");
str.AppendLine($"\t\t\t\tPlayer1HeroClass = CardClass.{heroClass1},");
str.AppendLine($"\t\t\t\tPlayer1Deck = new List<Card>()");
str.AppendLine("\t\t\t\t{");
str.AppendLine($"\t\t\t\t\tCards.FromName(\"{card.Name}\"),");
str.AppendLine("\t\t\t\t},");
str.AppendLine($"\t\t\t\tPlayer2HeroClass = CardClass.{heroClass2},");
str.AppendLine("\t\t\t\tShuffle = false,");
str.AppendLine("\t\t\t\tFillDecks = true,");
str.AppendLine("\t\t\t\tFillDecksPredictably = true");
str.AppendLine("\t\t\t});");
str.AppendLine("\t\t\tgame.StartGame();");
str.AppendLine("\t\t\tgame.Player1.BaseMana = 10;");
str.AppendLine("\t\t\tgame.Player2.BaseMana = 10;");
str.AppendLine($"\t\t\t//var testCard = Generic.DrawCard(game.CurrentPlayer, Cards.FromName(\"{card.Name}\"));");
str.AppendLine($"\t\t\t//game.Process(PlayCardTask.Any(game.CurrentPlayer, \"{card.Name}\"));");
str.AppendLine("\t\t}");
str.AppendLine();
}
str.AppendLine("\t}");
return(str.ToString());
}
/// <summary>
/// Check card values to determine if they are right (i.e. are into allowed range for each property)
/// </summary>
/// <param name="_type">Card type as enum</param>
/// <param name="_class">Card class as enum</param>
/// <param name="_set">Card set as enum</param>
/// <param name="_race">Card race as enum</param>
/// <param name="_quality">Card quality as enum</param>
/// <returns></returns>
public static CardError checkCard(CardType _type, CardClass _class, CardSet _set, CardRace _race, CardQuality _quality, string _name)
{
if ((_type < CardType.Minion) || (_type > CardType.Weapon))
{
return CardError.BadType;
}
// Wrong card class?
if ((_class < CardClass.Neutral) || (_class > CardClass.Druid))
{
return CardError.BadClass;
}
// Wrong card set?
if ((_set < CardSet.Basic) || (_set > CardSet.WhispersOfTheOldGods))
{
return CardError.BadSet;
}
// Wrong minion race?
if ((_type == CardType.Minion) && ((_race < CardRace.None) || (_race > CardRace.Pirate)))
{
return CardError.BadRace;
}
// Wrong card quality?
if ((_quality < CardQuality.Free) || (_quality > CardQuality.Legendary))
{
return CardError.BadQuality;
}
// Wrong (empty) name?
if (_name.Length == 0)
{
return CardError.BadName;
}
return CardError.None;
}
//取得卡号
public string GetCardNo(int icdev)
{
string hexkey = "ffffffffffff";
//装入密码模式
int mode = 0;
//第一个扇区装载密码
int secor = 1;
//读卡扇区
byte sector = 0;
//寻卡模式，可返复写卡
byte cardmode = 1;
//卡序号
ulong tempint = 0;
//地址，*4
int address = 2;
StringBuilder str = new StringBuilder();
if (icdev > 0)
{
if (CardClass.dc_load_key_hex(icdev, mode, secor, hexkey) == 0)
{
CardClass.dc_card(icdev, cardmode, ref tempint);
if (CardClass.dc_authentication(icdev, 0, sector) == 0)
{
if (CardClass.dc_read_hex(icdev, address, str) == 0)
{
CardClass.dc_beep(icdev, 10);
return(str.ToString());
}
}
}
}
return("");
}
private List <Card>[] GetClassCard(CardClass heroClass, Func <IEnumerable <Card>, IEnumerable <Card> > filter)
{
var cardSet = Cards.FormatTypeClassCards(Game.FormatType);
var classCards = filter.Invoke(cardSet[heroClass].Where(p => p.Class == heroClass));
return(new[] { classCards.ToList() });
}
private static string CreateMethode(string name,
IEnumerable <Card> values, bool?collect, CardSet set, CardType type,
CardClass cardClass)
{
var valuesOrdered = values
.Where(p => p.Set == set &&
(collect == null || p.Collectible == collect) &&
(type == CardType.INVALID && p.Type != CardType.HERO && p.Type != CardType.HERO_POWER || p.Type == type) &&
(cardClass == CardClass.INVALID || p.Class == cardClass))
.OrderBy(p => p.Type.ToString());
if (!valuesOrdered.Any())
{
return(null);
}
var str = new StringBuilder();
str.AppendLine($"\t\tprivate static void {name}(IDictionary<string, List<Enchantment>> cards)");
str.AppendLine("\t\t{");
foreach (var card in valuesOrdered)
{
str.Append(AddCardString(card));
str.Append(AddCardCode(card));
}
str.AppendLine("\t\t}");
return(str.ToString());
}
void OnMouseUpAsButton()
{
if (!isup)
{
nowclass = myclass;
transform.root.FindChild("page").SendMessage("onclass", myclass);
}
}
void newcardset(CardClass c)
{
Transform g = (Transform)Instantiate(cardsetpre, transform.position, transform.rotation);
g.parent = transform.parent;
playersets.Insert(playersets.Count-1,g);//插入到最后一位
transform.Translate(new Vector3(0, 0, -0.525f));
set s = new set();
s.id = -1;
s.classs = c;
g.SendMessage("Createnew", s);
}
// Use this for initialization
void Start () {
switch (name)
{
case "sq": myclass = CardClass.kpaladin;
break;
case "dly": myclass = CardClass.kdruid;
break;
case "zs": myclass = CardClass.kwarrior;
break;
case "ss": myclass = CardClass.kwarlock;
break;
case "fs": myclass = CardClass.kmage; OnMouseUpAsButton();//显示第1个
break;
case "dz": myclass = CardClass.krogue;
break;
case "ms": myclass = CardClass.kpriest;
break;
case "lr": myclass = CardClass.khunter;
break;
case "sm": myclass = CardClass.kshama;
break;
}
}
void setclass(CardClass c)
{
chooseClass = c;
}
void classfilterhide(CardClass c)
{
lastpostion = transform.localPosition;
if (lastpostion != transform.localPosition)
{
Debug.Log(lastpostion);
}
if (myclass==CardClass.kany)
{
gototwo();
return;
}
if (myclass!=c)
{
chide();
}
else
{
gotoone();
}
}
void setclass(CardClass c)
{
info.classs = c;
}
public static string ConvertClass(CardClass cardClass) => (int)cardClass < 2 || (int)cardClass > 10 ? null : CultureInfo.InvariantCulture.TextInfo.ToTitleCase(cardClass.ToString().ToLowerInvariant());
// Use this for initialization
void Start()
{
Log("--debuginfo--");
//开发用,随机出一个自己的职业
int r;
do
{
r=Random.Range(1, 11);
} while (r==6||r==10);//6 和10 是没有的.
myclass = (CardClass)r;
Log("随机出来的英雄是:"+myclass);
}
//对职业进行过滤
void onclass(CardClass c)
{
switch (c)
{
case CardClass.kwarrior: pagename.text = "战士";
break;
case CardClass.khunter: pagename.text = "猎人";
break;
case CardClass.kpaladin: pagename.text = "圣骑士";
break;
case CardClass.kdruid: pagename.text = "德鲁伊";
break;
case CardClass.krogue: pagename.text = "潜行者";
break;
case CardClass.kmage: pagename.text = "法师";
break;
case CardClass.kpriest: pagename.text = "牧师";
break;
case CardClass.kshama: pagename.text = "祭司萨满";
break;
case CardClass.kwarlock: pagename.text = "术士";
break;
case CardClass.kany: pagename.text = "中立";
break;
}
classcard.Clear();
foreach (card cin in playerscard)
{
if (cin.classs == c)
{
classcard.Add(cin);
}
}
oncost(nowcost);
}
void setclasss(CardClass c)
{
switch(c)
{
case CardClass.kdruid:
classs.text = "德鲁伊";
heroname.text = "玛法里奥";
setpic(dly);
break;
case CardClass.khunter:
classs.text = "猎人";
heroname.text = "雷克萨";
setpic(lr);
break;
case CardClass.kmage:
classs.text = "法师";
heroname.text = "吉安娜";
setpic(fs);
break;
case CardClass.kpaladin:
classs.text = "圣骑士";
heroname.text = "乌瑟尔";
setpic(sq);
break;
case CardClass.kpriest:
classs.text = "牧师";
heroname.text = "安度因";
setpic(ms);
break;
case CardClass.krogue:
classs.text = "潜行者";
heroname.text = "瓦莉拉";
setpic(dz);
break;
case CardClass.kshama:
classs.text = "萨满祭司";
heroname.text = "萨尔";
setpic(sm);
break;
case CardClass.kwarlock:
classs.text = "术士";
heroname.text = "古尔丹";
setpic(ss);
break;
case CardClass.kwarrior:
classs.text = "战士";
heroname.text = "加尔鲁什";
setpic(zs);
break;
}
//播放动画,
animation.Play();
}
