public static List <BaseCards> The4BestCards(List <BaseCards> cardCollection)
{
List <BaseCards> cardDeck = new List <BaseCards>();
BaseCards tempCard = null;
while (cardDeck.Count < 4)//solange weniger als 4 karten in der liste sind
{
int temp = 0;
for (int i = 0; i < cardCollection.Count; i++)
{
if (cardCollection[i].getCardDamage() >= temp) //der damager höher
{
//noch prüfen, ob noch nicht in der liste
bool isInList = CheckList(cardCollection[i], cardDeck);
if (isInList == false)
{
temp = cardCollection[i].getCardDamage();
tempCard = cardCollection[i];
}
}
}
cardDeck.Add(tempCard);
}
return(cardDeck);
}
public bool PutInLists(DbUser dbUser, BaseCards ownCard, TradingObject wantToHave)
{
bool indicator = false;
BaseCards wantedCard = wantToHave.card;
//ich selbst
string query = DbFunctions.MakeQueryForInsertCard(wantedCard, dbUser);
if (ExecuteQuery(query))
{
indicator = true;
}
//der andere
dbUser.uid = wantToHave.userUid;
query = DbFunctions.MakeQueryForInsertCard(ownCard, dbUser);
if (ExecuteQuery(query))
{
if (indicator == false)
{
return(false);
}
}
return(true);
}
public static bool ChekTrade(string cardWantToHave, List <TradingObject> cardListToTrade, string choiceToTrade, List <BaseCards> userCardcollection, string answerToTrade)
{
BaseCards card = userCardcollection[Int32.Parse(choiceToTrade) - 1];
BaseCards checkFromCard = cardListToTrade[Int32.Parse(cardWantToHave) - 1].card;
TradingObject tempObject = cardListToTrade[Int32.Parse(cardWantToHave) - 1];
bool indicator = false;
int damage = tempObject.requiredDamage; //damage den man will
string temp = tempObject.wantedCardType;
if (temp.Contains("Spell"))
{
if (MyEnum.cardTypes.Spell == card.getCardType())
{
if (card.getCardDamage() >= damage)
{
indicator = true;
}
}
}
else if (temp.Contains("Monster"))
{
if (MyEnum.cardTypes.Monster == card.getCardType())
{
if (card.getCardDamage() >= damage)
{
indicator = true;
}
}
}
return(indicator);
}
public static BaseCards MakeMonster(Random rand)
{
BaseCards tempCard = null;
//uid erstellen
string teststring = string.Format("{0:N}", Guid.NewGuid()); //erstellt eine unique Id
string uid = teststring.Substring(0, 9); //kürzt die ID auf 9 stellen
//entscheiden welchen typ also cardProperty
int randType = ChooseProperty(rand);
//entscheiden welche Eigenschaft also elementTypes
int randElement = ChooseElement(rand);
//entschieden wie viel damage
int damage = rand.Next(1, 51);
//irgwie da mit nem namen machen
string name = CreateNameMonster(rand);
//set the cardProperty
string card_Element = Enum.GetName(typeof(elementTypes), randElement);
elementTypes tempElement = ((elementTypes)Enum.Parse(typeof(elementTypes), card_Element));
string card_property = Enum.GetName(typeof(cardProperty), randType);
cardProperty tempProperty = ((cardProperty)Enum.Parse(typeof(cardProperty), card_property));
tempCard = new MonsterCard(uid, damage, name, tempElement, tempProperty);
return(tempCard);
}
public static bool ValidateAttack(BaseCards Player1, BaseCards Player2)
{
if ((Player1.getCardProperty() == cardProperty.Goblin) && (Player2.getCardProperty() == cardProperty.Dragon))
{
Console.WriteLine("Goblin cannot attack Dragon");
return(false);
}
else if ((Player1.getCardProperty() == cardProperty.Ork) && (Player2.getCardProperty() == cardProperty.Wizard))
{
Console.WriteLine("Org cannot attack Wizard");
return(false);
}
else if ((Player1.getCardProperty() == cardProperty.Knight) && (Player2.getCardType() == cardTypes.Spell) && (Player2.getElementTypes() == elementTypes.Water))
{
Console.WriteLine("Knight cannot attack WaterSpell");
return(false);
}
else if ((Player1.getCardProperty() == cardProperty.Kraken) && (Player2.getCardType() == cardTypes.Spell))
{
Console.WriteLine("Kraken is immune to Spells");
return(false);
}
else if ((Player1.getCardProperty() == cardProperty.Dragon) && (Player2.getCardProperty() == cardProperty.Elf) && (Player2.getElementTypes() == elementTypes.Fire))
{
Console.WriteLine("Dragon cannot attack FireElves");
return(false);
}
return(true);
}
public static string MakeMessageTradDelete(DbUser userFromDb, BaseCards card)
{
string temp = "DELETE FROM userdata_cardcollection WHERE ";
temp += "fk_user_uid = '" + userFromDb.uid + "' AND fk_card_uid = '" + card.getUID() + "';";
return(temp);
}
static string CheckCardtype(BaseCards Player)
{
if (Player.getCardType() == cardTypes.Monster)
{
return(Player.getCardProperty().ToString() + ", ");
}
return("");
}
public static string MakeQueryForInsertCard(BaseCards baseCard, DbUser user)
{
string temp = "Insert Into UserData_CardCollection\n" +
"(fk_user_uid, fk_card_uid)\n" +
"VALUES\n" +
"('" + user.uid + "', '" + baseCard.getUID() + "');";
return(temp);
}
public static string MakeQueryForCreateNewCard(BaseCards baseCard)
{
string temp = "Insert into cardcollection\n" +
"(card_uid, element_type, card_property, card_type, card_name, card_damage)\n" +
"VALUES\n" +
"('" + baseCard.getUID() + "', '" + baseCard.getElementTypes() + "', '" + baseCard.getCardProperty() + "', '" + baseCard.getCardType() + "', '" + baseCard.getCardName() + "', '" + baseCard.getCardDamage() + "');";
return(temp);
}
public int GetCardDamagePoints(BaseCards opponent)
{
if (opponent.CardProperty == CardProperty.Wizard)
{
return 0;
}
return this.CardDamage;
}
public int GetCardDamagePoints(BaseCards opponent)
{
if (opponent.CardProperty == CardProperty.FireElve)
{
return(0);
}
return(this.CardDamage);
}
public void TestMethod()
{
//arrange
//act
BaseCards winner = BattleLogic.Attack(_firedragon, _waterSpell);
//assert
Assert.AreEqual(_waterSpell.getCardDamage(), winner.getCardDamage());
}
public int GetCardDamagePoints(BaseCards opponent)
{
if (opponent.CardType == CardType.Spell && opponent.Element == ElementType.Water)
{
return(0);
}
return(this.CardDamage);
}
public void GetCardToUser(BaseCards baseCard, DbUser user)
{
string query = DbFunctions.MakeQueryForInsertCard(baseCard, user);
if (ExecuteQuery(query) == false)
{
//error weiterreichen
Console.WriteLine("error bei execute");
}
}
public static bool CheckList(BaseCards cardToAdd, List <BaseCards> cardDeck)
{
for (int i = 0; i < cardDeck.Count; i++)
{
if (cardDeck[i] == cardToAdd)
{
return(true);
}
}
return(false);
}
public static int CalcPreis(BaseCards card)
{
float temp = 0;
temp = card.getCardDamage() * 0.25f - 1f; //weil man in einem Pack 4 Karten bekommt, ein pack 25 coins kostet und der damage von 0 bis 50 sein kann
if (temp == 0)
{
temp = 1;
}
return(Convert.ToInt32(temp));
}
public List <BaseCards> GetCardsFromDb(string username)
{
List <BaseCards> cards = new List <BaseCards>();
string query = DbFunctions.MakeQueryGetCards(username);
//Console.WriteLine(query);
var commandDatabase = new NpgsqlCommand(query, _databaseConnection);
commandDatabase.CommandTimeout = 60;
try
{
_databaseConnection.Open();
var myReader = commandDatabase.ExecuteReader();
//Console.WriteLine(myReader);
if (myReader.HasRows)
{
//Console.WriteLine("Query Generated result:");
while (myReader.Read())
{
BaseCards temp = null;
//Console.WriteLine(myReader.GetValue(0) + " - " + myReader.GetString(1) + " - " + myReader.GetString(2) + " - " + myReader.GetValue(3) + " - " + myReader.GetValue(4) + " - " + myReader.GetValue(5));
//nur zur übersicht
string uid = myReader.GetString(0);
elementTypes tempElementTypes = (elementTypes)Enum.Parse(typeof(elementTypes), myReader.GetString(1));
cardTypes tempCardTypes = (cardTypes)Enum.Parse(typeof(cardTypes), myReader.GetString(2));
cardProperty tempCardProperty = (cardProperty)Enum.Parse(typeof(cardProperty), myReader.GetString(3));
string name = myReader.GetString(4);
int damage = myReader.GetInt32(5);
if (tempCardTypes == cardTypes.Monster)
{
temp = new MonsterCard(uid, damage, name, tempElementTypes, tempCardProperty);
}
else if (tempCardTypes == cardTypes.Spell)
{
temp = new SpellCard(uid, damage, name, tempElementTypes);
}
cards.Add(temp);
}
}
else
{
Console.WriteLine("Query Error!");
}
}
catch (Exception e)
{
Console.WriteLine("Query Error: " + e.Message);
}
_databaseConnection.Close();
return(cards);
}
public static int GetEffektivDemage(BaseCards first, BaseCards second)
{
double temp = first.getCardDamage();
switch (first.getElementTypes())
{
case elementTypes.Fire:
{
if (second.getElementTypes() == elementTypes.Normal)
{
Console.WriteLine("Feuer ist effektiv gegen Normal");
temp = first.getCardDamage() * 1.5;
}
else
{
temp = first.getCardDamage();
}
break;
}
case elementTypes.Water:
{
if (second.getElementTypes() == elementTypes.Fire)
{
Console.WriteLine("Wasser ist effektiv gegen Feuer");
temp = first.getCardDamage() * 1.5;
}
else
{
temp = first.getCardDamage();
}
break;
}
case elementTypes.Normal:
{
if (second.getElementTypes() == elementTypes.Water)
{
Console.WriteLine("Normal ist effektiv gegen Wasser");
temp = first.getCardDamage() * 1.5;
}
else
{
temp = first.getCardDamage();
}
break;
}
}
Console.WriteLine($"Der effektive Damage ist: {Convert.ToInt32(temp)} ");
return(Convert.ToInt32(temp));
}
public static bool CheckIfAddToDeckIsValide(BaseCards tempCard, DbUser userFromDb)
{
//nun kann ein benutzer eine karte leider auch mehrmals haben
int numbeCardcollection = WieOftHatErDieKarte(userFromDb.cardCollection, tempCard.getUID()); //so oft darf er eine bestimmte karte verwenden
int numbeDeck = WieOftHatErDieKarte(userFromDb.cardDeck, tempCard.getUID()); //so oft hat er die karte bereits im deck
if (numbeCardcollection > numbeDeck)
{
return(true);
}
return(false);
}
public void Init()
{
Players.Clear();
SelectedCards.Clear();
HandCards.Clear();
CurrentDiscards.Clear();
BaseCards.Clear();
CurrentStatus = GameStatus.CallLandlord;
ClaimCount = 4;
CurrentTurn = 0;
RestCardNum = 17;
Mutiple = 1;
CurrentMode = GameMode.MutiPlayer;
LastPlayer = "";
Landlord = "";
BaseScore = 1000;
}
public int GetCardDamagePoints(BaseCards opponent)
{
if (opponent.CardProperty == CardProperty.Kraken)
{
return(0);
}
if (Effectiveness(opponent) == 1)
{
return(this.CardDamage * 2);
}
else if (Effectiveness(opponent) == -1)
{
return(this.CardDamage / 2);
}
return(this.CardDamage);
}
public BaseCards GetOneCard(string card_uid)
{
BaseCards card = null;
string query = "Select * from cardcollection where card_uid = '" + card_uid + "'";
var commandDatabase = new NpgsqlCommand(query, _databaseConnection);
commandDatabase.CommandTimeout = 60;
try
{
_databaseConnection.Open();
var myReader = commandDatabase.ExecuteReader();
//Console.WriteLine(myReader);
while (myReader.Read())
{
string cardUid = myReader.GetString(0);
elementTypes tempElementTypes = (elementTypes)Enum.Parse(typeof(elementTypes), myReader.GetString(1));
cardTypes tempCardTypes = (cardTypes)Enum.Parse(typeof(cardTypes), myReader.GetString(2));
cardProperty tempCardProperty = (cardProperty)Enum.Parse(typeof(cardProperty), myReader.GetString(3));
string name = myReader.GetString(4);
int damage = myReader.GetInt32(5);
if (tempCardTypes == cardTypes.Monster)
{
card = new MonsterCard(cardUid, damage, name, tempElementTypes, tempCardProperty);
}
else if (tempCardTypes == cardTypes.Spell)
{
card = new SpellCard(cardUid, damage, name, tempElementTypes);
}
}
}
catch (Exception e)
{
Console.WriteLine("Query Error: " + e.Message);
}
_databaseConnection.Close();
return(card);
}
public bool UpdateCardsByTrade(DbUser dbUser, BaseCards card, TradingObject tradingListe)
{
bool indicator = false;
//löschen aus cartencollction
string queryDelete = "Delete From userdata_cardcollection where fk_user_uid = '" + dbUser.uid
+ "' and fk_card_uid = '" + card.getUID() + "'";
if (ExecuteQuery(queryDelete))
{
indicator = true;
}
//löschen aus tauschliste
queryDelete = "delete from userdata_cardcollectiontotrade where fk_user_uid = '" + tradingListe.userUid
+ "' and fk_card_uid = '" + tradingListe.cardUid + "'";
if (ExecuteQuery(queryDelete))
{
if (indicator == false)
{
return(false);
}
}
return(true);
}
public void GenerateNewCards(Random rand)
{
Thread.Sleep(rand.Next(1, 17));
int howManyCards = 100;
while (howManyCards > 0)
{
BaseCards baseCard = CardShop.GetRandCard(rand);
Console.WriteLine(baseCard.getCardName());
string query = DbFunctions.MakeQueryForCreateNewCard(baseCard);
if (ExecuteQuery(query) == false)
{
//error weiterreichen
Console.WriteLine("error bei execute");
}
howManyCards--;
}
}
public int GetCardDamagePoints(BaseCards opponent)
{
return(this.CardDamage);
}
public static void StartServer()
{
List <DbUser> clientList = new List <DbUser>();
int port = 6543;
Console.Write("Waiting for a connection... ");
TcpListener listener = new TcpListener(IPAddress.Any, port);
listener.Start();
try
{
while (true) //akzeptiert alle clients die kommen
{
if (listener.Pending())
{
TcpClient client = listener.AcceptTcpClient();
string data = "";
new Thread(() =>
{
try
{
Console.WriteLine("\nClient Connected!");
bool loggedIn = false;
DbUser userFromDb = new DbUser();
NetworkStream stream = null;
RequestContext request = new RequestContext();
ServerDbConnection mypostgresDataClass = new ServerDbConnection();
int attempt = 3; //muss ich noch hinzufügen
bool registered = false;
while (loggedIn == false)
{
stream = client.GetStream();
data = ServerClientConnection.ReceiveData(client, stream);
//Console.WriteLine("SERVER RECEIVED:\n" + data);
//data verwalten und in ein Objekt speichern
request = MessageHandler.GetRequest(data);
if (request.message.Trim('\n') == "Login")
{
//check if login
if (attempt == 0)
{
string tempMessage = "AccessDenied";
SendData(stream, tempMessage);
//string gabadge = ServerClientConnection.receiveData(client, stream);
break;
}
else
{
userFromDb = DbFunctions.VerifyLogin(request, stream);
}
if ((userFromDb == null))
{
attempt--;
//client antworten und pw und user neu eingeben
string message = "please try again\n";
SendData(stream, message);
}
else
{
loggedIn = true;
}
//wieder auf nachricht warten
//er ist nun eingeloggt
}
else if (request.message.Trim('\n') == "Register")
{
if (attempt == 0)
{
string tempMessage = "AccessDenied";
ServerClientConnection.SendData(stream, tempMessage);
Console.WriteLine("Du hast keine Versuche mehr");
Console.ReadLine();
break;
}
else
{
registered = DbFunctions.RegisterAtDb(request, stream);
if (registered == true)
{
string tempMessage = "YouAreRegistred\n";
ServerClientConnection.SendData(stream, tempMessage);
userFromDb = DbFunctions.VerifyLogin(request, stream);
break;
}
}
//setup for register
if (registered == false)
{
attempt--;
string tempMessage = "TryAgain\n";
ServerClientConnection.SendData(stream, tempMessage);
}
}
}
while (true)
{
string sieger = "noOne";
data = "";
//request.message = "empty";
data = ServerClientConnection.ReceiveData(client, stream);
//Console.WriteLine("SERVER RECEIVED:\n" + data);
//daten wieder einlesen
request = MessageHandler.GetRequest(data);
//also nach dem einloggen, kann ein client man hier her
//brauch ich dann auch für später
if (request.message.Trim('\n') == "StartTheBattle")
{
Console.WriteLine("Das battle beginnt in kürze");
//statt den rand card muss ich jz die von einem user abfragen
//request.cardDeck = BattleMaker.GetRandCards();
request.stream = stream;
userFromDb.stream = stream;
string tempusername = request.GetUsernameFromDict();
string username = "";
string[] tempToken = tempusername.Split(new char[] { '_' });
//falls auch _ im usernamen drinnen sind
for (int i = 0; i < tempToken.Length - 1; i++)
{
username += tempToken[i];
}
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(username);
//wenn er zu weinige Karten besitzt
if (userFromDb.cardCollection.Count < 3)
{
SendData(stream, "Du musst zuerst karten kaufen");
continue;
}
//standardmäßig mal das auswählen
if (userFromDb.cardDeck.Count == 0)
{
userFromDb.cardDeck = BattleMaker.The4BestCards(userFromDb.cardCollection);
}
clientList.Add(userFromDb);
//noch lock hinzufügen
while (sieger.Trim('\n') == "noOne")
{
if (!clientList.Contains(userFromDb))
{
break;
}
_mut.WaitOne();
sieger = BattleMaker.AddToBattleQueue(clientList);
Thread.Sleep(1000);
_mut.ReleaseMutex();
}
if (request.GetUsernameFromDict().Contains(sieger))
{
//elo points erhöhen
Console.WriteLine(sieger);
string query = DbFunctions.MakeQueryForUpdateElo(userFromDb, "+3");
mypostgresDataClass.ExecuteQuery(query);
}
else
{
//elo points minus
Console.WriteLine(request.GetUsernameFromDict());
string query = DbFunctions.MakeQueryForUpdateElo(userFromDb, "-5");
mypostgresDataClass.ExecuteQuery(query);
}
//clientList.RemoveAt(0);
clientList.Remove(userFromDb);
}
else if (request.message.Trim('\n') == "OptainNewCards")
{
List <BaseCards> tempList = new List <BaseCards>();
Console.WriteLine("4 cards cost 25 Coins" !);
//string choiceCardShop = Console.ReadLine().Trim(' ', '\n');
var tempListForAnswerToClient = DbFunctions.OptainNewCards(userFromDb, Server.rand);
if (tempListForAnswerToClient == null)
{
SendData(stream, "ZuWenigeCoins");
}
else
{
string tempStringForAnswerToClient = GetAllNames(tempListForAnswerToClient);
SendData(stream, tempStringForAnswerToClient);
}
}
else
if (request.message.Trim('\n') == "ShowDeck")
{
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(userFromDb.userName);
string answer;
if (userFromDb.cardDeck.Count == 0)
{
if (userFromDb.cardCollection == null)
{
answer = "NoCards";
}
else
{
userFromDb.cardDeck = BattleMaker.The4BestCards(userFromDb.cardCollection);
answer = GetAllNames(userFromDb.cardDeck);
}
}
else
{
answer = GetAllNames(userFromDb.cardDeck);
}
SendData(stream, answer);
}
else if (request.message.Trim('\n') == "ShowCardCollection")
{
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(userFromDb.userName);
string answer = String4ShowCardCollection(userFromDb.cardCollection);
SendData(stream, answer);
}
else if (request.message.Trim('\n') == "Trade4Coins")
{
while (true)
{
//Console.WriteLine("ready to trade");
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(userFromDb.userName);
string answer = GetAllNames(userFromDb.cardCollection);
SendData(stream, answer);
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
if (request.message.Trim('\n') == "END")
{
break;
}
else
{
//die karte an der stelle löschen, coins hochzählen, aus der datenbank löschen
//1. aus der datenbank löschen, dann kann man nur die karten neu laden
int cardToTrade = Int32.Parse(request.message);
//Console.WriteLine(userFromDb.cardCollection[cardToTrade - 1].getCardName()); //eins abziehen, weil die client eingabe bei 1 startet
//Console.WriteLine(" ");
//noch die coins anzeigen
if (cardToTrade > userFromDb.cardCollection.Count)
{
SendData(stream, "Wrong input\n do you want to continue?");
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
if (request.message.Trim('\n') == "YES")
{
continue;
}
break;
}
int preis = CalcPreis(userFromDb.cardCollection[cardToTrade - 1]);
//answer ob to sell
if (preis == 0)
{
preis = 1;
}
string message = MakeMessageToSellCoinsAsk(preis);
SendData(stream, message);
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
if (request.message.Trim('\n') == "YES")
{
message = DbFunctions.MakeMessageTradDelete(userFromDb, userFromDb.cardCollection[cardToTrade - 1]);
bool successQueryExecute = DbFunctions.PassQuery(message);
//coins hochzählen
userFromDb.coins += preis;
string makeQuery4UpdateCoins = DbFunctions.MakeQueryForUpdateCoins(userFromDb);
successQueryExecute = DbFunctions.PassQuery(makeQuery4UpdateCoins);
}
else if (request.message.Trim('\n') == "NO")
{
break;
}
}
}
}
else if (request.message.Trim('\n') == "TradeWithPlayer")
{
//ähnlich wie battle logic
//eine karte auswählen, in queue hinzufügen
//zweiten spieler hinzufügen, queue is nicht leer
//zweiter spieler wählt eine karte aus, die er tauschen will
//datenbank wird aktualisiert
//beide werden aus der queue gelöscht
string input = "";
//choose a card
userFromDb.cardDeck = new List <BaseCards>();
BaseCards tempCard = null;
//hier kann man die Karten auswählen, die im deck sein sollen
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(userFromDb.userName);
string answer = String4ShowCardCollection(userFromDb.cardCollection);
SendData(stream, answer); //schickt die possible karten
int number;
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
input = request.message.Trim('\n');
if (input == "1")
{
//man will eine karte hinzufügen
//die zahl kommt als antwort und die will ich hochladen
while (true)
{
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
number = Int32.Parse(request.message);
if (number <= userFromDb.cardCollection.Count)
{
SendData(stream, "OK");
break;
}
else
{
SendData(stream, "False");
}
}
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
string spellOrMonster = request.message.Trim('\n');
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
string requiredDamage = request.message.Trim('\n');
mypostgresDataClass.AddCardsToTrade(userFromDb, number - 1, spellOrMonster, requiredDamage);
}
else if (input == "2")
{
//man will nur tauschen
//zeigt alle karten in der liste zum tauschen an
List <TradingObject> tradingListe = DbFunctions.ReturnCardsToTradeCards();
string answerToTrade = DbFunctions.ReturnCardsToTradeString();
SendData(stream, answerToTrade);
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
string cardWantToHave = request.message.Trim('\n');
//wähle aus eigenen karten aus
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(userFromDb.userName);
answer = String4ShowCardCollection(userFromDb.cardCollection);
SendData(stream, answer); //schickt die possible karten
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
string choiceToTrade = request.message.Trim('\n');
//prüfe, ob valide
bool checker = DbFunctions.ChekTrade(cardWantToHave, tradingListe, choiceToTrade, userFromDb.cardCollection, answerToTrade);
//lösche aus eigener kartenliste und tauschliste
if (checker == true)
{
checker = mypostgresDataClass.UpdateCardsByTrade(userFromDb, userFromDb.cardCollection[Int32.Parse(choiceToTrade) - 1], tradingListe[Int32.Parse(cardWantToHave) - 1]);
}
if (checker == true)
{
SendData(stream, "correctChoice");
}
else
{
SendData(stream, "wrongChoice");
}
//füge in eigene liste ein
mypostgresDataClass.PutInLists(userFromDb, userFromDb.cardCollection[Int32.Parse(choiceToTrade) - 1], tradingListe[Int32.Parse(cardWantToHave) - 1]);
}
}
else if (request.message.Trim('\n') == "ChangeTheDeck")
{
userFromDb.cardDeck = new List <BaseCards>();
BaseCards tempCard = null;
//hier kann man die Karten auswählen, die im deck sein sollen
userFromDb.cardCollection = mypostgresDataClass.GetCardsFromDb(userFromDb.userName);
string answer = String4ShowCardCollection(userFromDb.cardCollection);
SendData(stream, answer);
while (userFromDb.cardDeck.Count < 4)
{
data = ReceiveData(client, stream);
request = MessageHandler.GetRequest(data);
int number = Int32.Parse(request.message) - 1; //wwil bei 0 zu zählen beginnen
if (userFromDb.cardCollection.Count < number)
{
SendData(stream, "NumberToHigh");
continue;
}
tempCard = userFromDb.cardCollection[number];
//tscheck if falide
//eine karte darf z.b nur einmal drinnen sein
if (CheckIfAddToDeckIsValide(tempCard, userFromDb))
{
userFromDb.cardDeck.Add(tempCard);
SendData(stream, GetAllNames(userFromDb.cardDeck));
}
else
{
SendData(stream, "cardAlreadyUsed");
continue;
}
}
}
else if (request.message.Trim('\n') == "ShowScoreboard")
{
string playerScore = mypostgresDataClass.GetEloPoints();
SendData(stream, playerScore);
}
else
{
Console.WriteLine("Some unknown error!");
Console.ReadLine();
return;
}
}
}
catch (Exception e)
{
Console.WriteLine("Error {0}!", e);
}
}).Start();
}
}
}
catch (System.ArgumentException e)
{
Console.WriteLine(e);
}
catch (Exception e)
{
Console.WriteLine("Error {0}!", e);
}
}
public static BaseCards Attack(BaseCards attacker, BaseCards defender)
{
int damageAttacker;
int damageDefender;
switch (attacker.getCardType())
{
case cardTypes.Monster when defender.getCardType() == cardTypes.Monster:
Console.WriteLine($"Der effektive Damage ist: {attacker.getCardDamage()} ");
Console.WriteLine($"Der effektive Damage ist: {defender.getCardDamage()} ");
if (attacker.getCardDamage() > defender.getCardDamage())
{
return(attacker);
}
return(defender);
case cardTypes.Monster when defender.getCardType() == cardTypes.Spell:
// monster attacks Spell
damageAttacker = GetEffektivDemage(attacker, defender);
damageDefender = GetEffektivDemage(defender, attacker);
if (damageAttacker > damageDefender)
{
return(attacker);
}
return(defender);
case cardTypes.Spell when defender.getCardType() == cardTypes.Monster:
// nur wenn nicht beide NORMAL sind
damageAttacker = GetEffektivDemage(attacker, defender);
damageDefender = GetEffektivDemage(defender, attacker);
if (damageAttacker > damageDefender)
{
return(attacker);
}
else
{
return(defender);
}
case cardTypes.Spell when defender.getCardType() == cardTypes.Spell:
//Spell attacks Spell
damageAttacker = GetEffektivDemage(attacker, defender);
damageDefender = GetEffektivDemage(defender, attacker);
if (damageAttacker > damageDefender)
{
return(attacker);
}
return(defender);
default:
// TODO: consider throw new InvalidDataException ?
Console.WriteLine("Error occured!");
return(attacker);
}
}
public BaseCards GetOneRandCardFromDb(string query, int cardsNumber, int rand)
{
BaseCards temp = null;
NpgsqlCommand commandDatabase = new NpgsqlCommand(query, _databaseConnection);
commandDatabase.CommandTimeout = 60;
int cardPlace = rand;
cardPlace = cardPlace % cardsNumber;
if (cardPlace == 0)
{
cardPlace = 1;
}
int counter = 0;
try
{
_databaseConnection.Open();
var myReader = commandDatabase.ExecuteReader();
//Console.WriteLine(myReader);
if (myReader.HasRows)
{
Console.WriteLine("Query Generated result:");
while (myReader.Read())
{
//Console.WriteLine(myReader.GetValue(0) + " - " + myReader.GetString(1) + " - " + myReader.GetString(2) + " - " + myReader.GetValue(3) + " - " + myReader.GetValue(4) + " - " + myReader.GetValue(5));
//nur zur übersicht
string cardUid = myReader.GetString(0);
elementTypes tempElementTypes = (elementTypes)Enum.Parse(typeof(elementTypes), myReader.GetString(1));
cardTypes tempCardTypes = (cardTypes)Enum.Parse(typeof(cardTypes), myReader.GetString(2));
cardProperty tempCardProperty = (cardProperty)Enum.Parse(typeof(cardProperty), myReader.GetString(3));
string name = myReader.GetString(4);
int damage = myReader.GetInt32(5);
if (tempCardTypes == cardTypes.Monster)
{
temp = new MonsterCard(cardUid, damage, name, tempElementTypes, tempCardProperty);
}
else if (tempCardTypes == cardTypes.Spell)
{
temp = new SpellCard(cardUid, damage, name, tempElementTypes);
}
counter++;
if (counter == cardPlace)
{
break;
}
}
}
else
{
Console.WriteLine("Query Error!");
}
}
catch (Exception e)
{
Console.WriteLine("Query Error: " + e.Message);
}
_databaseConnection.Close();
return(temp);
}
static void PrintInformationFromOneCard(BaseCards Player1, BaseCards Player2)
{
Console.WriteLine($"{Player1.getCardType()}, {Player1.getElementTypes()}, {CheckCardtype(Player1)} {Player1.getCardName()}, | attacks | {Player2.getCardType()}, {Player2.getElementTypes()}, {CheckCardtype(Player2)} {Player2.getCardName()}");
}
public static int StartBattle(List <BaseCards> Cards4Battle1, List <BaseCards> Cards4Battle2)
{
Random rnd = new Random();
int counterLoop = 0;
int a = 0, b = 0;
List <BaseCards> Dummy = new List <BaseCards>();
while ((Test4Winner(Cards4Battle1.Count, Cards4Battle2.Count) == false) && (counterLoop < 100))
{
Console.WriteLine($"----------------------------- Round {counterLoop +1} ----------------------------------");
int cardPlayer1 = rnd.Next(Cards4Battle1.Count); // creates a number from 0 to 3
int cardPlayer2 = rnd.Next(Cards4Battle2.Count);
//Console.WriteLine("Player one card {0}", cardPlayer1);
//Console.WriteLine("Player two card {0}", cardPlayer2);
BaseCards Player1;
BaseCards Player2;
BaseCards winner = null;
Player1 = Cards4Battle1[cardPlayer1];
Player2 = Cards4Battle2[cardPlayer2];
PrintInformationFromOneCard(Player1, Player2);
//validate
if (ValidateAttack(Player1, Player2) == false)
{
winner = Player2;
}
else
{
winner = Attack(Player1, Player2);
}
if (winner == Player1)
{
Cards4Battle1.Add(Cards4Battle2[cardPlayer2]);
Cards4Battle2.Remove(Cards4Battle2[cardPlayer2]);
}
else if (winner == Player2)
{
Cards4Battle2.Add(Cards4Battle1[cardPlayer1]);
Cards4Battle1.Remove(Cards4Battle1[cardPlayer1]);
}
//bei einem unetschieden, passiert nichts
Console.WriteLine("Player one ammount {0}", Cards4Battle1.Count);
Console.WriteLine("Player two ammount {0}", Cards4Battle2.Count);
counterLoop++;
}
if (a == 0)
{
Console.WriteLine("The winner is Player 2");
return(2);
}
if (b == 0)
{
Console.WriteLine("The winner is Player 1");
return(1);
}
return(0);
}
