/// <summary>
/// Setzt die Beziehungen zwischen zwei Spielern
/// </summary>
/// <param name="userA">Benutzer 1</param>
/// <param name="userB">Benutzer 2</param>
/// <param name="state">Beziehungsstatus</param>
public void setRelation(User userA, User userB, RelationState state)
{
RelationHolder[] list2 = new RelationHolder[list.Count];
this.list.CopyTo(list2);
foreach (RelationHolder hold in list2)
{
if (((userA == hold.userA) && (userB == hold.userB)) || ((userB == hold.userA) && (userA == hold.userB)))
{
list.Remove(hold);
RelationHolder holder = new RelationHolder();
holder.userA = userA;
holder.userB = userB;
holder.state = state;
list.Add(holder);
return;
}
}
//Nicht in der Liste => neu Einfügen;
RelationHolder holder2 = new RelationHolder();
holder2.userA = userA;
holder2.userB = userB;
holder2.state = state;
list.Add(holder2);
}
private Station( StationClass type, User UID, string name, string states)
{
this.type = type;
this.uid = UID;
this.name = name;
this.states = states;
}
/// <summary>
/// Erstellt ein neues Schiff
/// </summary>
/// <param name="type">Typ des Schiffes</param>
/// <param name="UID">Der Besitzer des Schiffes</param>
/// <param name="name">Der Name des Schiffes</param>
/// <param name="fleet">Die Flotte, in der das Schiff ist</param>
/// <param name="states">Die Zustände die ein Schiff hat</param>
public Ship(ShipClass type, User UID, string name, int fleet, string states)
{
this.type = type;
this.uid = UID;
this.name = name;
this.fleet = fleet;
this.states = states;
}
private Troop(int ID, TroopClass type, User UID, string name, int team, string states)
{
id = ID;
this.type = type;
this.uid = UID;
this.name = name;
this.team = team;
this.states = states;
}
/// <summary>
/// Liefert alle Updates eines Spielers zurück
/// </summary>
/// <param name="user">Spieler</param>
/// <returns>Alle Updates eines Spielers</returns>
public List<Update> getUpdates(User user)
{
if (updatelist.ContainsKey(user))
{
return updatelist[user];
}
else
{
return new List<Update>();
}
}
/// <summary>
/// Fügt einem Spieler einen bestimmten Resourcen Betrag hinzu
/// </summary>
/// <param name="user">Benutzer, dem die Resourcen hinzugefügt werden sollen</param>
/// <param name="resources">Liste der Resourcen</param>
public void addRes(User user, ResList resources)
{
lock (resourceList)
{
foreach (KeyValuePair<ResType, double> get in resources)
{
addRes(user, get.Key, get.Value);
}
}
}
/// <summary>
/// Liefert den Beziehungsstatus, der zwischen den beiden angegebenen Spielern besteht
/// </summary>
/// <param name="userA">Benutzer 1</param>
/// <param name="userB">Benutzer 2</param>
/// <returns>Beziehungsstatus</returns>
public RelationState getRelation(User userA, User userB)
{
foreach (RelationHolder hold in list)
{
if (((userA == hold.userA) && (userB == hold.userB)) || ((userB == hold.userA) && (userA == hold.userB)))
{
return hold.state;
}
}
return defaultstate;
}
/// <summary>
/// Fügt einem Spieler eine Technologie hinzu
/// </summary>
/// <param name="user">Spieler</param>
/// <param name="tech">Technologie</param>
public void addTech(User user, Tech tech)
{
lock (techlist)
{
List<Tech> have = getTechs(user);
if (!have.Contains(tech))
{
techlist[user].Add(tech);
}
}
}
/// <summary>
/// Fügt einem Spieler einen bestimmten Resourcen Betrag hinzu
/// </summary>
/// <param name="user">Benutzer, dem die Resourcen hinzugefügt werden sollen</param>
/// <param name="type">Resourcen Typ</param>
/// <param name="count">Resourcen Betrag</param>
public void addRes(User user, ResType type, double count)
{
if (count < 0)
{
throw new ArgumentException("Der Wert von Count darf nicht kleiner als 0 sein!");
}
if (!resourceList.ContainsKey(user))
{
addUser(user);
}
lock (resourceList)
{
resourceList[user][type] += count;
}
}
/// <summary>
/// Helferfunktion, die den Resourcengewinn der Spieler regelt
/// </summary>
/// <param name="user">Benutzer</param>
private void fkt_checkRes(User user)
{
List<Station> stationList = game.getStations();
foreach (Station stat in stationList)
{
if (stat.Uid == user)
{
ResList gain = stat.Type.create_res;
addRes(user, gain);
}
}
List<Planet> planetenList = game.getPlanets();
foreach (Planet planet in planetenList)
{
if (planet.UID == user)
{
ResList gain = planet.type.create_res;
addRes(user, gain);
}
}
foreach (KeyValuePair<ResType, double> res in resourceList[user])
{
if (res.Value > maxres)
{
resourceList[user][res.Key] = maxres;
}
}
}
/// <summary>
/// Zieht einem Spieler einen bestimmten Resourcen Betrag ab
/// </summary>
/// <param name="user">Benutzer, von dem die Resourcen abgezogen werden sollen</param>
/// <param name="type">Resourcen Typ</param>
/// <param name="count">Resourcen Betrag</param>
public void subRes(User user, ResType type, double count)
{
if (count < 0)
{
throw new ArgumentException("Der Wert von Count darf nicht kleiner als 0 sein!");
}
if (!resourceList.ContainsKey(user))
{
addUser(user);
}
if ((resourceList[user][type] - count) < 0)
{
throw new GameException("Der Spieler hat nicht genügend Resourcen");
}
lock (resourceList)
{
resourceList[user][type] -= count;
}
}
/// <summary>
/// Überprüft ob ein Spieler mehr als einen bestimmten Betrag an Resourcen besitzt.
/// </summary>
/// <param name="user">Benutzer, für den die abfrage durchgeführt werden soll</param>
/// <param name="price">ResList Objekt mit den Kosten</param>
/// <returns>Boolscher Wert, der angibt, ob ein Spieler die benötigten Resouren besitzt</returns>
public bool haveRes(User user, ResList price)
{
ResList have = getResources(user);
foreach (KeyValuePair<ResType, double> want in price)
{
if (want.Value > have[want.Key])
{
return false;
}
}
return true;
}
/// <summary>
/// Liefert die Resourcen eines Spielers zurück
/// </summary>
/// <param name="user">Benutzer für den die Resourcen abgefragt werden sollen</param>
/// <returns>Die Resourcen in einer ResList. 0 sollte Spieler nicht in der Liste sein.</returns>
public ResList getResources(User user)
{
if (resourceList.ContainsKey(user))
{
return resourceList[user];
}
else
{
return new ResList();
}
}
/// <summary>
/// Liefert alle erforschten Technologien eines Spielers zurück
/// </summary>
/// <param name="user">Spieler</param>
/// <returns>Alle erforschten Technologien</returns>
public List<Tech> getTechs(User user)
{
if ((techlist.ContainsKey(user)) && (techlist[user] != null))
{
return techlist[user];
}
return new List<Tech>();
}
/// <summary>
/// Erzeugt ein Dummy Objekt dieser Klasse, um es für Kampfsimulationen einzusetzten.
/// </summary>
/// <param name="type">Typ</param>
/// <param name="name">Name</param>
/// <returns>Eins Instanz dieser Klasse</returns>
public static Troop createDummy(TroopClass type, string name)
{
User user = new User(0, "Dummy", "0", new Race(0, "Dummy"));
Troop objekt = new Troop(0, type, user, name, 0, "");
objekt.power = type.power;
objekt.power2 = type.power2;
objekt.power3 = type.power3;
objekt.power4 = type.power4;
objekt.resistend1 = type.resistend1;
objekt.resistend2 = type.resistend2;
objekt.resistend3 = type.resistend3;
objekt.resistend4 = type.resistend4;
objekt.health = type.health;
objekt.fighterTyp = FighterType.TROOP;
return objekt;
}
/// <summary>
/// Überprüft die Updates für einen Spieler
/// </summary>
/// <param name="user">Spieler</param>
private void CheckUpdates(User user)
{
List<Ship> listships = game.getShips();
List<Station> liststations = game.getStations();
List<Update> updates = getUpdates(user);
foreach (Ship ship in listships)
{
if (ship.Uid == user)
{
ship.power = ship.Type.power;
ship.power2 = ship.Type.power2;
ship.power3 = ship.Type.power3;
ship.power4 = ship.Type.power4;
ship.resistend1 = ship.Type.resistend1;
ship.resistend2 = ship.Type.resistend2;
ship.resistend3 = ship.Type.resistend3;
ship.resistend4 = ship.Type.resistend4;
ship.speed = ship.Type.speed;
foreach (Update update in updates)
{
if (update.shiptype == ship.Type)
{
ship.power += update.strength;
ship.power2 += update.strength2;
ship.power3 += update.strength3;
ship.power4 += update.strength4;
ship.resistend1 += update.resistend1;
ship.resistend2 += update.resistend2;
ship.resistend3 += update.resistend3;
ship.resistend4 += update.resistend4;
ship.speed += update.speed;
}
}
}
}
foreach (Station station in liststations)
{
if (station.Uid == user)
{
station.power = station.Type.power;
station.power2 = station.Type.power2;
station.power3 = station.Type.power3;
station.power4 = station.Type.power4;
station.resistend1 = station.Type.resistend1;
station.resistend2 = station.Type.resistend2;
station.resistend3 = station.Type.resistend3;
station.resistend4 = station.Type.resistend4;
foreach (Update update in updates)
{
if (update.stattype == station.Type)
{
station.power += update.strength;
station.power2 += update.strength2;
station.power3 += update.strength3;
station.power4 += update.strength4;
station.resistend1 += update.resistend1;
station.resistend2 += update.resistend2;
station.resistend3 += update.resistend3;
station.resistend4 += update.resistend4;
}
}
}
}
// Überprüfung ob die Datenbankeinträge passen.
List<Tech> listtech = main.modulmanager.tech.getTechs(user);
List<Update> shouldHave = new List<Update>();
foreach (Tech tech in listtech)
{
foreach (Update up in tech.update)
{
shouldHave.Add(up);
}
}
foreach (Update up in shouldHave)
{
if (!updates.Contains(up))
{
updatelist[user].Add(up);
}
}
}
/// <summary>
/// Fügt einen Spieler der Liste hinzu
/// </summary>
/// <param name="user">Spieler</param>
public void addUser(User user)
{
techlist.Add(user, new List<Tech>());
}
/// <summary>
/// Subroutine für checkTech
/// </summary>
/// <param name="user">Benutzer für den die Überprüfung durchgeführt werden soll</param>
private void fkt_checkTech(User user)
{
if (researchlist.ContainsKey(user))
{
List<Forschung> list = researchlist[user];
foreach (Forschung forschung in list)
{
int finish = forschung.Started + forschung.Tech.time;
if (finish <= main.Round)
{
// Forschung fertig:
addTech(user, forschung.Tech);
researchlist[user].Remove(forschung);
}
}
}
}
/// <summary>
/// Entfert eine Technologie von einem Spieler
/// </summary>
/// <param name="user">Spieler</param>
/// <param name="tech">Technologie</param>
public void removeTech(User user, Tech tech)
{
lock (techlist)
{
List<Tech> have = getTechs(user);
if (have.Contains(tech))
{
techlist[user].Remove(tech);
}
}
}
/// <summary>
/// Überprüft ob ein Spieler eine Technologie besitzt
/// </summary>
/// <param name="user">Spieler</param>
/// <param name="tech">Zu Überprüfende Technologie</param>
/// <returns>Besitzt ein Spieler eine Technologie</returns>
public bool haveTech(User user, Tech tech)
{
return getTechs(user).Contains(tech);
}
/// <summary>
/// Fügt einen Spieler der Liste hinzu
/// </summary>
/// <param name="user">Spieler</param>
public void addUser(User user)
{
resourceList.Add(user, new ResList());
}
/// <summary>
/// Erstellt eine neue Forschung
/// </summary>
/// <param name="user">Der Benutzer dem die Foschung gehört</param>
/// <param name="tech">Die Technologie die erforscht wird</param>
/// <param name="started">Die Zeit wann Sie gestartet wurde</param>
public Forschung(User user, Tech tech, int started)
{
this.user = user;
this.tech = tech;
this.started = started;
}
/// <summary>
/// Liefert alle Forschungen eines Spielers zurück
/// </summary>
/// <param name="user">Spieler</param>
/// <returns>Liste aller Forschungen</returns>
public List<Forschung> getResearch(User user)
{
if (researchlist.ContainsKey(user))
{
return researchlist[user];
}
else
{
return new List<Forschung>();
}
}
/// <summary>
/// Liefert eine ganz bestimmte Resource eines Spieler zurück
/// </summary>
/// <param name="user">Benutzer für den die Resource abgefragt werden soll</param>
/// <param name="type">Resourcen Typ</param>
/// <returns>Anzahl der entsprechenden Resource</returns>
public double getResource(User user, ResType type)
{
if (resourceList.ContainsKey(user))
{
ResList list = resourceList[user];
return list[type];
}
return 0;
}