public void Post([FromBody] string value)
{
var deck = DeckService.LoadDeck(value);
deck = DeckService.ShuffleDeckCards(deck);
Game.Deck1 = deck;
}
static void Main(string[] args)
{
// I would use dependency injection, normally, to create the service
var deckService = new DeckService();
var deck = deckService.CreateDeck();
var andrewHand = deckService.CreateHandCards(deck, new Player
{
Name = "Andrew"
});
var benHand = deckService.CreateHandCards(deck, new Player
{
Name = "Ben"
});
Console.WriteLine($"{andrewHand.Player.Name}'s Hand:");
foreach (var card in andrewHand.PlayerHand)
{
Console.WriteLine(card);
}
Console.WriteLine($"{benHand.Player.Name}'s Hand:");
foreach (var card in benHand.PlayerHand)
{
Console.WriteLine(card);
}
Console.WriteLine("Remaining Cards:");
foreach (var element in deck.GameDeck)
{
Console.WriteLine(element);
}
}
public void Start()
{
Instance = this;
AsyncTasks = new Queue <Action>(300);
FrameActions = new MapList <Action>(300);
Config.InitConfig();
DataService.LoadData();
TextureService.LoadTextures();
DeckService.LoadForbiddenLists();
imgSelector = new Lazy <ImageSelector>();
tglSelector = new Lazy <ToggleSelector>();
confirmWindow = new Lazy <ConfirmWindow>();
annWindow = new Lazy <AnnounceWindow>();
opSelector = new Lazy <OptionSelector>();
inputBox = new Lazy <InputBox>();
hint = new Lazy <HintBox>();
lazyDescriptor = new Lazy <CardDescriptor>();
lazyChat = new Lazy <ChatWindow>();
ToolStrip = new ToolStrip();
DuelWindow = new DuelWindow();
DeckBuilder = new DeckBuilder();
RoomWindow = new RoomWindow();
Menu = new MainMenu();
ConfigWindow = new ConfigWindow();
ServerWindow = new ServerWindow();
Field = new Field();
Duel = new ClientDuel();
Menu.Show();
}
/// <summary>
/// Get all existing decks by a particular title.
/// </summary>
/// <param name="title"></param>
/// <returns></returns>
public IHttpActionResult Get(string title)
{
DeckService deckService = CreateDeckService();
var deck = deckService.GetDeckByTitle(title);
return(Ok(deck));
}
public void Setup()
{
this.context = HubContextImplementation.GetContext;
this.cardRepository = new CardRepository();
this.deckRepository = new DeckRepository();
this.discussionResultRepository = new DiscussionResultRepository();
this.roomRepository = new RoomRepository();
this.userRepository = new UserRepository();
this.userService = new UserService(this.userRepository, this.context);
this.cardService = new CardService(this.cardRepository, this.context, this.userService);
this.deckService = new DeckService(this.deckRepository, this.cardRepository, this.context, this.userService);
this.discussionResultService = new DiscussionResultService(this.discussionResultRepository, this.cardRepository, this.userRepository);
this.roomService = new RoomService(this.roomRepository, this.userRepository, this.deckRepository, this.context, this.userService, this.discussionResultService);
this.userService.AddUserToConnectionMap("TestUser", "TestConnection");
this.cards = new Cards();
this.decks = new Decks();
this.discussionResults = new DiscussionResults();
this.rooms = new Rooms();
this.users = new Users();
InvokedSignalRMethod = string.Empty;
}
public void TestDetermineWinner()
{
var player1 = new Player
{
PlayerName = "Test1"
};
player1.PlayerHand = new Hand
{
Cards = BuildRoyalFlush()
};
var player2 = new Player
{
PlayerName = "Test2"
};
player2.PlayerHand = new Hand
{
Cards = BuildHighCard()
};
var winner = DeckService.DetermineWinner(player1, player2);
Assert.AreEqual(player1, winner);
}
private DeckService CreateDeckService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var deckService = new DeckService(userId);
return(deckService);
}
private DeckService CreateDeckService()
{
var userId = User.Identity.GetUserId();
var service = new DeckService(userId);
return(service);
}
private static void AddCard(ref DeckService deckService)
{
Console.WriteLine("Enter the name of the deck: ");
var name = Console.ReadLine();
var deck = deckService.GetDeck(name);
if (deck == null)
{
Console.WriteLine("The deck not found.\n");
return;
}
Console.WriteLine("\n\nEnter a name for the new card: ");
name = Console.ReadLine();
ushort number;
try
{
Console.WriteLine("\nEnter the number of the card: ");
number = ushort.Parse(Console.ReadLine() !);
}
catch (Exception)
{
Console.WriteLine("Input error.\n");
return;
}
var result = DeckService.AddCard(ref deck, name, number);
Console.WriteLine(result.Message);
}
public EnemyManagerService(
GameObject enemyObjectPrefab,
GameObject enemyContainer,
PlayerService playerService,
EnemyService enemyService,
EnemyTurnService enemyTurnService,
StatusService statusService,
DeckService deckService,
EnemyTypes enemyTypes,
CardUiManager cardUiManager,
CardGeneratorService cardGeneratorService,
SceneUiManager sceneUiManager,
UpgradeUiManager upgradeUiManager,
UpgradeService upgradeService
)
{
this.enemyObjectPrefab = enemyObjectPrefab;
this.enemyContainer = enemyContainer;
this.enemyService = enemyService;
this.enemyTurnService = enemyTurnService;
this.statusService = statusService;
this.playerService = playerService;
this.deckService = deckService;
this.enemyTypes = enemyTypes;
this.cardUiManager = cardUiManager;
this.cardGeneratorService = cardGeneratorService;
this.sceneUiManager = sceneUiManager;
this.upgradeUiManager = upgradeUiManager;
this.upgradeService = upgradeService;
}
public void InitializeServices()
{
this.hubService = new Mock <ISignalRHubService>();
this.userService = new UserService(this.users);
this.roomService = new RoomService(this.hubService.Object, this.rooms, this.users);
this.deckService = new DeckService(this.decks);
}
// GET: Create
public ActionResult Create(int id, bool isCard)
{
var userId = User.Identity.GetUserId();
var deckService = new DeckService(userId);
var cardService = new CardService();
if (isCard)
{
var allDecks = deckService.GetDecks();
var card = cardService.GetCardById(id);
var cardToDeck = new AssignmentViewModel(isCard)
{
CardId = id,
CardName = card.Name,
DeckList = allDecks
};
return(View(cardToDeck));
}
var allCards = cardService.GetCards();
var deck = deckService.GetDeckById(id);
var deckToCard = new AssignmentViewModel(isCard)
{
DeckId = id,
DeckName = deck.Name,
CardList = allCards
};
return(View(deckToCard));
}
public void DeleteDeckTest003_RemoveActiveDeckRef()
{
Deck deckToDelete = Deck.CreateNewDeck();
ObservableCollection <Deck> decks = new ObservableCollection <Deck>();
List <Reward> rewards = new List <Reward>();
ObservableCollection <Game> games = new ObservableCollection <Game>();
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Decks).Returns(decks);
tracker.Setup(t => t.Rewards).Returns(rewards);
tracker.Setup(t => t.ActiveDeck).Returns(deckToDelete);
tracker.Setup(t => t.Games).Returns(games);
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
DeckService deckService = new DeckService(trackerFactory.Object);
deckService.DeleteDeck(deckToDelete);
tracker.VerifySet(t => t.ActiveDeck = null);
// Assert.AreEqual(null, tracker.Object.ActiveDeck);
}
/// <summary>
/// Get all existing decks.
/// </summary>
/// <returns></returns>
public IHttpActionResult Get()
{
DeckService deckService = CreateDeckService();
var decks = deckService.GetDecks();
return(Ok(decks));
}
public void DeleteDeckTest004_ActiveDeckOther()
{
Deck deckToDelete = Deck.CreateNewDeck();
ObservableCollection <Deck> decks = new ObservableCollection <Deck>();
List <Reward> rewards = new List <Reward>();
ObservableCollection <Game> games = new ObservableCollection <Game>();
Deck activeDeck = Deck.CreateNewDeck();
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Decks).Returns(decks);
tracker.Setup(t => t.Rewards).Returns(rewards);
tracker.Setup(t => t.ActiveDeck).Returns(activeDeck); //some other deck
tracker.Setup(t => t.Games).Returns(games);
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
DeckService deckService = new DeckService(trackerFactory.Object);
deckService.DeleteDeck(deckToDelete);
Assert.AreEqual(activeDeck, tracker.Object.ActiveDeck);
}
/// <summary>
/// Get a single deck by id.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public IHttpActionResult Get(int id)
{
DeckService deckService = CreateDeckService();
var deck = deckService.GetDeckById(id);
return(Ok(deck));
}
/// <summary>
/// Get all existing decks by category.
/// </summary>
/// <param name="category"></param>
/// <returns></returns>
public IHttpActionResult GetByCategory(string category)
{
DeckService deckService = CreateDeckService();
var deck = deckService.GetDecksByCategoryTitle(category);
return(Ok(deck));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
PassingBrayContext.Cards = DeckService.Shuffle();
}
/// <summary>
/// Конструктор класса SignalR хаба
/// </summary>
/// <param name="userService"> Сервис работы с пользователями </param>
/// <param name="roomService"> Сервис работы с комнатами </param>
/// <param name="deckService"> Сервис работы с колодами </param>
/// <param name="hubService"> Сервис работы с хабом SignalR </param>
public SignalRHub(UserService userService, RoomService roomService, DeckService deckService, ISignalRHubService hubService)
{
this.hubService = hubService;
this.roomService = roomService;
this.deckService = deckService;
this.userService = userService;
}
public string GetWinner(string playerInfo)
{
// the players in this game, assume there are always only 2
var players = JsonConvert.DeserializeObject <List <Player> >(playerInfo);
var winner = DeckService.DetermineWinner(players[0], players[1]);
return($"Winner is {winner.PlayerName} with {AttributeUtil.GetAttributeValue<NameAttribute>(typeof(HandResult.HandResults), HandResult.DetermineHandResult(winner.PlayerHand).Item1.ToString(), nameof(NameAttribute.Name))}");
}
public void GetCardsTest()
{
List <Card> cards = DeckService.GetCards();
Assert.IsTrue(cards.Count() == 52);
Assert.IsTrue(cards.Any(c => c.CardType == CardType.Club) && cards.Any(c => c.CardType == CardType.Diamond));
//Asserting that we have a variety of 52.
}
public IEnumerable <string> Get()
{
var card = DeckService.DrawCard(Game.Deck1);
return(new List <string> {
card.Url
});
}
public void Setup()
{
var dbContextoptions = new DbContextOptionsBuilder <ModelContext>().UseInMemoryDatabase("TestDB");
db = new ModelContext(dbContextoptions.Options);
db.Database.EnsureCreated();
deck = new DeckService(db);
}
// GET: Deck
public ActionResult Index()
{
var userId = User.Identity.GetUserId();
var service = new DeckService(userId);
var model = service.GetDecks();
return(View(model));
}
private static void Main()
{
var deckService = new DeckService();
var cont = true;
do
{
Console.WriteLine(
"What to do?\n\n1 - add a deck\n2 - print a deck\n3 - quit\n4 - add a card\n5 - sort a deck\n6 - unsort a deck\n7 - get deck info");
int command;
try
{
command = int.Parse(Console.ReadLine() !);
}
catch (Exception)
{
Console.WriteLine("Input error.");
continue;
}
switch (command)
{
case 1:
AddDeck(ref deckService);
break;
case 2:
PrintDeck(ref deckService);
break;
case 3:
cont = false;
break;
case 4:
AddCard(ref deckService);
break;
case 5:
SortDeck(ref deckService);
break;
case 6:
UnsortDeck(ref deckService);
break;
case 7:
GetDeckInfo(ref deckService);
break;
default:
Console.WriteLine("Wrong command");
break;
}
} while (cont);
}
public void InitializeServices()
{
this.hubService = new Mock <ISignalRHubService>();
this.userService = new UserService(this.users);
this.roomService = new RoomService(this.hubService.Object, this.rooms, this.users);
this.roundService = new RoundService(this.hubService.Object, new TimerService(), this.rooms, this.rounds, this.users, this.decks);
this.deckService = new DeckService(this.decks);
this.cardService = new CardService(this.cards);
}
public void DeleteDeckTest001_RemoveDeck()
{
Deck deckToDelete = Deck.CreateNewDeck();
ObservableCollection <Deck> decks = new ObservableCollection <Deck>()
{
Deck.CreateNewDeck(),
deckToDelete,
Deck.CreateNewDeck()
};
ObservableCollection <Game> games = new ObservableCollection <Game>()
{
new Game()
{
Deck = deckToDelete
},
new Game()
{
Deck = Deck.CreateNewDeck()
},
new Game()
{
Deck = Deck.CreateNewDeck()
},
new Game()
{
Deck = Deck.CreateNewDeck()
},
new Game()
{
Deck = Deck.CreateNewDeck()
},
};
List <Reward> rewards = new List <Reward>();
Mock <ITracker> tracker = new Mock <ITracker>();
tracker.Setup(t => t.Decks).Returns(decks);
tracker.Setup(t => t.Rewards).Returns(rewards);
tracker.Setup(t => t.Games).Returns(games);
Mock <ITrackerFactory> trackerFactory = new Mock <ITrackerFactory>();
trackerFactory.Setup(tf => tf.GetTracker()).Returns(tracker.Object);
DeckService deckService = new DeckService(trackerFactory.Object);
deckService.DeleteDeck(deckToDelete);
Assert.AreEqual(4, games.Count);
Assert.IsFalse(games.Any(g => g.DeckId == null || g.DeckId == deckToDelete.DeckId));
Assert.AreEqual(2, decks.Count);
Assert.IsFalse(decks.Contains(deckToDelete));
}
public DeckFacade(
EntityFrameworkUnitOfWorkProvider <MtgDbContext> unitOfWorkProvider,
DeckService deckService,
Func <DeckGetByUserQuery> deckGetByUserQueryFactory,
IMapper mapper)
: base(unitOfWorkProvider, mapper)
{
this.deckService = deckService;
this.deckGetByUserQueryFactory = deckGetByUserQueryFactory;
}
public void GetHandScoreTest()
{
List <Card> testCards = new List <Card>();
testCards.Add(new Card(CardType.Diamond, new CardWorth(new KeyValuePair <string, int?>("Five", 5)), true));
testCards.Add(new Card(CardType.Club, new CardWorth(new KeyValuePair <string, int?>("Six", 6)), true));
player1.Hand.AddRange(testCards);
Assert.IsTrue(DeckService.GetHandScore(player1) == 11);
Assert.IsTrue(player1.CurrentScore == 11);
}
public void CompareHands()
{
// validate draw/equal cards
Assert.AreEqual(DeckService.CompareCard(new string[] { "AH", "KH", "QH", "JH", "10H" }, new string[] { "10D", "JD", "QD", "KD", "AD" }, Deck.Hand.RoyalFlush), Deck.CompareHand.Equal);
// validate higher card
Assert.AreEqual(DeckService.CompareCard(new string[] { "AH", "KH", "QH", "JH", "10H" }, new string[] { "10D", "JD", "QD", "KD", "9D" }, Deck.Hand.RoyalFlush), Deck.CompareHand.Higher);
// validate lower card
Assert.AreEqual(DeckService.CompareCard(new string[] { "9h", "Kh", "Qh", "Jh", "10h" }, new string[] { "10D", "JD", "QD", "KD", "AD" }, Deck.Hand.RoyalFlush), Deck.CompareHand.Lower);
}
