Scoreboards 1.8.x - Sideboard und Tablist

Hier könnt ihr anderen Leuten helfen, indem ihr Anleitungen oder praktische Codesegmente zur Verfügung stellt.

Scoreboards 1.8.x - Sideboard und Tablist

Beitragvon IcySkill » Sa 17. Okt 2015, 18:41

Hey Community,

nachdem ich schon vor langer Zeit vor hatte eine Anleitung zu posten, es aber dann doch nicht gemacht habe, möchte ich das nun hier nachholen. Aber zuerst ist zu sagen, das dieses Tutorial NICHT für komplette Anfänger ist. Ich werde versuchen, den Code so gut es geht verständlich zu erklären. Falls ihr Fragen/Probleme habt, könnt ihr mir gerne eine PN schreiben oder das Problem/die Frage hier mit #ScoreboardsSupport posten (Damit ich den Post leichter finden kann). Also genug geredet - los geht's!

INHALTSVERZEICHNIS:

1.) Side-Scoreboard - setzen und konfigurieren
2.) Side-Scoreboard - Scores updaten
2.1) Side-Scoreboard - Score-Name updaten


3.) Tablist-Scoreboard - Teams erstellen
4.) Tablist-Scoreboard - Teams Spieler hinzufügen/entfernen


5.) Schlusswort und Dankesagung



1.) Side-Scoreboard - setzen und konfigurieren
Dazu erstellen wir uns als aller Erstes eine neue Java-Klasse, die wir BoardManager nennen, da ScoreboardManager bereits von Bukkit/Spigot verwendet wird und es damit keine Komplikationen geben soll. Dort erstellen wir eine HashMap mit "Player" als Key (K) und "Scoreboard" als Value (V), die wir dann "boards" nennen. Diese muss zusätzlich als "static" definiert werden, damit man die folgende Methode im PlayerJoinEvent ausführen kann. Zusätzlich erstellen wir uns eine Variable, die die Hauptklasse darstellt.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.entity.Player;
  3. import org.bukkit.scoreboard.Scoreboard;
  4. /**
  5. *
  6. * @author IcySkill
  7. */
  8. public class BoardManager {
  9.     private ScoreboardTutorial plugin;
  10.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  11.    
  12. }


Die Methode, von der ich gerade gesprochen habe, ist die "setScoreboard" Methode. In ihr werden wir einen Spieler benötigen, den wir gleich im Konstruktor dieser Methode angeben. Zusätzlich müssen wir diese Methode auch als "static" definieren. Hier erstellen wir uns nun das Scoreboard (welches ein "getNewScoreboard()" sein muss da wir das "getMainScoreboard()" in der tablist verwenden), das den Spielern bzw. dem Spieler angezeigt wird und das Objective erstellen wir gleich mit.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.Objective;
  5. import org.bukkit.scoreboard.Scoreboard;
  6. /**
  7. *
  8. * @author IcySkill
  9. */
  10. public class BoardManager {
  11.     private ScoreboardTutorial plugin;
  12.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  13.    
  14.     public static void setScoreboard(Player player) {
  15.         Scoreboard board = Bukkit.getScoreboardManager().getNewScoreboard();
  16.         Objective objective = board.registerNewObjective("Tutorial", "dummy");
  17.     }
  18. }


Jetzt haben wir 2 String beim Objective anzugeben. Der erste String, ist der Name des Objectives, in meinem Falle nenne ich es "Tutorial". Der zweite String, ist die Art des Objectives. Um es frei konfigurieren zu können, nutzen wir "dummy" als Art. Nun setzen wir DisplaySlot und Displayname des Scoreboards.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.DisplaySlot;
  5. import org.bukkit.scoreboard.Objective;
  6. import org.bukkit.scoreboard.Scoreboard;
  7. /**
  8. *
  9. * @author IcySkill
  10. */
  11. public class BoardManager {
  12.     private ScoreboardTutorial plugin;
  13.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  14.    
  15.     public static void setScoreboard(Player player) {
  16.         Scoreboard board = Bukkit.getScoreboardManager().getNewScoreboard();
  17.         Objective objective = board.registerNewObjective("Tutorial", "dummy");
  18.         objective.setDisplaySlot(DisplaySlot.SIDEBAR);
  19.         objective.setDisplayName("TestTutorial");
  20.     }
  21. }


Hier nutzen wir den DisplaySlot "Sidebar", damit das Scoreboard rechts an der Seite angezeigt wird. Letztendlich müssen wir nur noch Scores setzen, das Scoreboard in die HashMap packen und es dem Spieler setzen. Aber als erstes setzen wir die Scores mit "objective.getScore(DieserNameWirdAngezeigt).setScore(BeliebigerInteger);". Ich habe es zu Demonstration Zwecken mit Kills und Deaths gemacht.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.DisplaySlot;
  5. import org.bukkit.scoreboard.Objective;
  6. import org.bukkit.scoreboard.Scoreboard;
  7. /**
  8. *
  9. * @author IcySkill
  10. */
  11. public class BoardManager {
  12.     private ScoreboardTutorial plugin;
  13.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  14.    
  15.     public static void setScoreboard(Player player) {
  16.         Scoreboard board = Bukkit.getScoreboardManager().getNewScoreboard();
  17.         Objective objective = board.registerNewObjective("Tutorial", "dummy");
  18.         objective.setDisplaySlot(DisplaySlot.SIDEBAR);
  19.         objective.setDisplayName("TestTutorial");
  20.        
  21.         int kills = 12;
  22.         int deaths = 8;
  23.         objective.getScore("§6Kills:   ").setScore(kills);
  24.         objective.getScore("§9Tode:   ").setScore(deaths);
  25.     }
  26. }


Zum Schluss, setzen wir das Scoreboard samt Spieler noch in die HashMap und setzen es dem Spieler.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.DisplaySlot;
  5. import org.bukkit.scoreboard.Objective;
  6. import org.bukkit.scoreboard.Scoreboard;
  7. /**
  8. *
  9. * @author IcySkill
  10. */
  11. public class BoardManager {
  12.     private ScoreboardTutorial plugin;
  13.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  14.    
  15.     public static void setScoreboard(Player player) {
  16.         Scoreboard board = Bukkit.getScoreboardManager().getNewScoreboard();
  17.         Objective objective = board.registerNewObjective("Tutorial", "dummy");
  18.         objective.setDisplaySlot(DisplaySlot.SIDEBAR);
  19.         objective.setDisplayName("TestTutorial");
  20.        
  21.         int kills = 12;
  22.         int deaths = 8;
  23.         objective.getScore("§6Kills:   ").setScore(kills);
  24.         objective.getScore("§9Tode:   ").setScore(deaths);
  25.        
  26.         boards.put(player, board);
  27.         player.setScoreboard(board);
  28.     }
  29. }


Nun wird das Scoreboard gesetzt und man kann es jederzeit updaten wie ich im nächsten Kapitel zeige.



2.) Side-Scoreboard - Scores updaten
Nachdem wir das Scoreboard nun gesetzt haben, wollen wir es natürlich auch updaten, was wir mit folgender Methode machen werden "updateScoreboard(Player player)". Hier müssen wir wieder einen Spieler mitübergeben, damit auch das richtige Scoreboard geupdatet wird. Diese Methode erstellen wir nun. (Es ist immer noch die gleiche Klasse, ich habe nur die "setScoreboard()" Methode zur Übersicht entfernt)
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.DisplaySlot;
  5. import org.bukkit.scoreboard.Objective;
  6. import org.bukkit.scoreboard.Scoreboard;
  7. /**
  8. *
  9. * @author IcySkill
  10. */
  11. public class BoardManager {
  12.     private ScoreboardTutorial plugin;
  13.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  14.    
  15.     public static void updateScoreboard(Player player) {
  16.         Scoreboard board = boards.get(player);
  17.         Objective objective = board.getObjective("Tutorial");
  18.     }
  19. }


Hier machen wir das gleiche wie beim erstellen des Scoreboards, der eizigste Unterscheid ist, das wir kein neues Scoreboard sowie Objective erstellen, sondern das bereits für den entsprechenden Spieler erstellte Scoreboard bekommen. Beim Objective müssen wir den Gleichen Namen nutzen, den wir beim erstellen als ObjectiveName genutzt haben. Nun updaten wir die Scores mit der Gleichen Methode, mit der wir die Scores auch gesetzt haben, nur mit einem neuen Integer.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.DisplaySlot;
  5. import org.bukkit.scoreboard.Objective;
  6. import org.bukkit.scoreboard.Scoreboard;
  7. /**
  8. *
  9. * @author IcySkill
  10. */
  11. public class BoardManager {
  12.     private ScoreboardTutorial plugin;
  13.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  14.    
  15.     public static void updateScoreboard(Player player) {
  16.         Scoreboard board = boards.get(player);
  17.         Objective objective = board.getObjective("Tutorial");
  18.        
  19.         int newKills = 23;
  20.         int newDeaths = 11;
  21.         objective.getScore("§6Kills:   ").setScore(newKills);
  22.         objective.getScore("§9Tode:   ").setScore(newDeaths);
  23.     }
  24. }


Nachdem wir die Scores geupdatet haben, müssen wir nun auch das Scoreboard in der HashMap updaten. Das machen wir, indem wir das alte Scoreboard aus der HashMap löschen, und das neue, geupdatete Scoreboard wieder rein setzen.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.Bukkit;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.DisplaySlot;
  5. import org.bukkit.scoreboard.Objective;
  6. import org.bukkit.scoreboard.Scoreboard;
  7. /**
  8. *
  9. * @author IcySkill
  10. */
  11. public class BoardManager {
  12.     private ScoreboardTutorial plugin;
  13.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  14.    
  15.     public static void updateScoreboard(Player player) {
  16.         Scoreboard board = boards.get(player);
  17.         Objective objective = board.getObjective("Tutorial");
  18.        
  19.         int newKills = 23;
  20.         int newDeaths = 11;
  21.         objective.getScore("§6Kills:   ").setScore(newKills);
  22.         objective.getScore("§9Tode:   ").setScore(newDeaths);
  23.        
  24.         boards.remove(player);
  25.         boards.put(player, board);
  26.     }
  27. }


Nun könnt ihr euer Scoreboard auch updaten.



2.1) Side-Scoreboard - Score-Name updaten
Hier werde ich nicht so genau darauf eingehen, nur die Funktionsweise erklären. Um den ScoreName zu updaten, müssen wir den Score immer abspeichern, damit wir ihn nachher zurücksetzen können. Danach nimmt man den neuen ScoreName und setzt ihn mit dem gleichen Integer, wie den Score davor.
Code: Alles auswählen
  1. import java.util.HashMap;
  2. import org.bukkit.entity.Player;
  3. import org.bukkit.scoreboard.Objective;
  4. import org.bukkit.scoreboard.Scoreboard;
  5. /**
  6. *
  7. * @author IcySkill
  8. */
  9. public class BoardManager {
  10.     private ScoreboardTutorial plugin;
  11.     private static HashMap<Player, Scoreboard> boards = new HashMap<>();
  12.     String oldName = "Kills:   " + 3;
  13.     String newName = "Kills:   " + 8;
  14.    
  15.     public static void updateScoreboardScore(Player player, String oldName, String newName) {
  16.         Scoreboard board = boards.get(player);
  17.         Objective objective = board.getObjective("TestObjective");
  18.         int IntegerNachWahl = 5;    // Dieser int steht lediglich dafür, an welcher Position der Score im Scoreboard steht.
  19.         board.resetScores(oldName);
  20.         objective.getScore(newName).setScore(IntegerNachWahl);
  21.         boards.remove(player);
  22.         boards.put(player, board);
  23.     }
  24. }


Achtung! Dieser Code dient nur zur Veranschaulichung und ist nicht zur direkten Verwendung gedacht!



3.) Tablist-Scoreboard - Teams erstellen
Als erstes müssen wir das Scoreboard in der Haupt-Klasse definieren. Dazu erstellen wir uns ein nicht definiertes Scoreboard mit "public Scoreboard scoreboard;". Um das wichtigste nicht zu vergessen, definieren wir das Scoreboard gleich im "onEnable()" Teil mit "scoreboard = Bukkit.getScoreboardManager().getManinScoreboard();". Hier das ganze mal in Code Form zur Übersicht:
Code: Alles auswählen
  1. import org.bukkit.Bukkit;
  2. import org.bukkit.plugin.java.JavaPlugin;
  3. import org.bukkit.scoreboard.Scoreboard;
  4. /**
  5. *
  6. * @author IcySkill
  7. */
  8. public class ScoreboardTutorial extends JavaPlugin {
  9.     public Scoreboard scoreboard;
  10.     @Override
  11.     public void onEnable() {
  12.         scoreboard = Bukkit.getScoreboardManager().getMainScoreboard();
  13.     }
  14. }


Nun wird das Scoreboard beim Start des Servers schon mal definiert und geladen. Um es jetzt noch nutzen zu können, müssen wir uns einen sogenannten "Getter" erstellen, welcher eigentlich nur eine Methode ist, die in diesem Fall das Scoreboard zurück gibt.
Code: Alles auswählen
  1. public Scoreboard getScoreboard() {
  2.         return scoreboard;
  3.     }


Diesen schreiben wir unter die "onEnable()" Methode, um die Übersicht zu behalten. Anschließend erstellen wir uns eine neue Java-Klasse, die wir TeamManager nennen. In dieser klasse definieren wir wieder die Hauptklasse in eine Variable und erstellen und einen Konstruktor, sowie eine mit "static" definierte ArrayList wo wir als Value "Team" setzen.
Code: Alles auswählen
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import org.bukkit.scoreboard.Team;
  4. /**
  5. *
  6. * @author IcySkill
  7. */
  8. public class TeamManager {
  9.     private ScoreboardTutorial plugin;
  10.     private static List<Team> teams = new ArrayList<>();
  11.    
  12.     public TeamManager(ScoreboardTutorial plugin) {
  13.         this.plugin = plugin;
  14.     }
  15. }


Nun müssen wir die Teams definieren. Ich demonstriere es an 2 Teams, dies ist aber erweiterbar. Also erstellen wir uns 2 als "static" definierte Teams, ich nenne das erste "admins" und das zweite "developer". Anschließend müssen wir diese Teams noch in unserem Scoreboard registrieren bzw. abfragen, ob sie schon registriert sind und fügen die Teams dann der ArrayList "teams" hinzu.
Code: Alles auswählen
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import org.bukkit.scoreboard.Team;
  4. /**
  5. *
  6. * @author IcySkill
  7. */
  8. public class TeamManager {
  9.     private ScoreboardTutorial plugin;
  10.     private static List<Team> teams = new ArrayList<>();
  11.     static Team admins;
  12.     static Team developer;
  13.    
  14.     public TeamManager(ScoreboardTutorial plugin) {
  15.         this.plugin = plugin;
  16.         if(plugin.getScoreboard().getTeam("admins") == null) {
  17.             plugin.getScoreboard().registerNewTeam("admins");
  18.             admins = plugin.getScoreboard().getTeam("admins");
  19.             admins.setPrefix("§cAdmin : ");
  20.         } else {
  21.             admins = plugin.getScoreboard().getTeam("admins");
  22.             admins.setPrefix("§cAdmin : ");
  23.         }
  24.         teams.add(admins);
  25.         if(plugin.getScoreboard().getTeam("developer") == null) {
  26.             plugin.getScoreboard().registerNewTeam("developer");
  27.             developer= plugin.getScoreboard().getTeam("developer");
  28.             developer.setPrefix("§3Dev : ");
  29.         } else {
  30.             developer= plugin.getScoreboard().getTeam("developer");
  31.             developer.setPrefix("§3Dev : ");
  32.         }
  33.         teams.add(developer);
  34.     }
  35. }


Nun müssen wir den TeamManager beim Start des Plugins noch laden, und das machen wir, indem wir ihn in der Haupt-Klasse definieren.
Code: Alles auswählen
  1. import org.bukkit.Bukkit;
  2. import org.bukkit.plugin.java.JavaPlugin;
  3. import org.bukkit.scoreboard.Scoreboard;
  4. /**
  5. *
  6. * @author IcySkill
  7. */
  8. public class ScoreboardTutorial extends JavaPlugin {
  9.     public Scoreboard scoreboard;
  10.     TeamManager teamManager;
  11.     @Override
  12.     public void onEnable() {
  13.         scoreboard = Bukkit.getScoreboardManager().getMainScoreboard();
  14.         teamManager = new TeamManager(this);
  15.     }
  16.    
  17.     public Scoreboard getScoreboard() {
  18.         return scoreboard;
  19.     }
  20. }


Damit wäre das erstellen der Teams auch schon erledigt.



4.) Tablist-Scoreboard - Teams Spieler hinzufügen/entfernen
Zum hinzufügen eines Spielers erstellen wir uns eine mit "static" definierte Methode namens "addToTeam(Player player, String team)", wo wir einmal einen Spieler und einmal einen String übergeben müssen. In dieser Methode fragen wir ab, ob der Spieler bereits in einem Team ist, wenn ja wird er aus dem Team entfernt und dem neuen zugewiesen. Zusätzlich wird der Name überall entsprechend dem Rang gesetzt.
Code: Alles auswählen
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.Team;
  5. /**
  6. *
  7. * @author IcySkill
  8. */
  9. public class TeamManager {
  10.     private ScoreboardTutorial plugin;
  11.     private static List<Team> teams = new ArrayList<>();
  12.     static Team admins;
  13.     static Team developer;
  14.    
  15.     public TeamManager(ScoreboardTutorial plugin) {
  16.         this.plugin = plugin;
  17.         if(plugin.getScoreboard().getTeam("admins") == null) {
  18.             plugin.getScoreboard().registerNewTeam("admins");
  19.             admins = plugin.getScoreboard().getTeam("admins");
  20.             admins.setPrefix("§cAdmin : ");
  21.         } else {
  22.             admins = plugin.getScoreboard().getTeam("admins");
  23.             admins.setPrefix("§cAdmin : ");
  24.         }
  25.         teams.add(admins);
  26.         if(plugin.getScoreboard().getTeam("developer") == null) {
  27.             plugin.getScoreboard().registerNewTeam("developer");
  28.             admins = plugin.getScoreboard().getTeam("developer");
  29.             admins.setPrefix("§3Dev : ");
  30.         } else {
  31.             admins = plugin.getScoreboard().getTeam("developer");
  32.             admins.setPrefix("§3Dev : ");
  33.         }
  34.         teams.add(developer);
  35.     }
  36.    
  37.     public static void addToTeam(Player player, String team) {
  38.         for(Team allTeams : teams) {
  39.             if(allTeams.hasEntry(player.getName())) allTeams.removeEntry(player.getName());
  40.         }
  41.         switch(team) {
  42.             case "admin":
  43.                 admins.addEntry(player.getName());
  44.                 player.setPlayerListName(admins.getPrefix() + player.getName());
  45.                 player.setDisplayName(admins.getPrefix() + player.getName());
  46.                 player.setCustomName(admins.getPrefix() + player.getName());
  47.                 break;
  48.             case "developer":
  49.                 developer.addEntry(player.getName());
  50.                 player.setPlayerListName(developer.getPrefix() + player.getName());
  51.                 player.setDisplayName(developer.getPrefix() + player.getName());
  52.                 player.setCustomName(developer.getPrefix() + player.getName());
  53.                 break;
  54.         }
  55.     }
  56. }


Jetzt könnt ihr zum Beispiel im PlayerJoinEvent abfragen, ob der Spieler eine bestimmte Permission hat und je nach dem das Team mit dieser Methode setzen.

Zum entfernen eines Spielers erstellen wir und eine mit "static" definierte Methode und nennen sie "removeFromTeams(Player player)", wo wir nur den Spieler übergeben müssen. Nun fragen wir mit einer For-Schleife ab, ob der Spieler in einem Team ist und entfernen ihn dann aus diesem Team. Dann setzen wir den Namen des Spielers wieder zurück und dann wäre das auch geschafft.
Code: Alles auswählen
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import org.bukkit.entity.Player;
  4. import org.bukkit.scoreboard.Team;
  5. /**
  6. *
  7. * @author IcySkill
  8. */
  9. public class TeamManager {
  10.     private ScoreboardTutorial plugin;
  11.     private static List<Team> teams = new ArrayList<>();
  12.     static Team admins;
  13.     static Team developer;
  14.    
  15.     public TeamManager(ScoreboardTutorial plugin) {
  16.         this.plugin = plugin;
  17.         if(plugin.getScoreboard().getTeam("admins") == null) {
  18.             plugin.getScoreboard().registerNewTeam("admins");
  19.             admins = plugin.getScoreboard().getTeam("admins");
  20.             admins.setPrefix("§cAdmin : ");
  21.         } else {
  22.             admins = plugin.getScoreboard().getTeam("admins");
  23.             admins.setPrefix("§cAdmin : ");
  24.         }
  25.         teams.add(admins);
  26.         if(plugin.getScoreboard().getTeam("developer") == null) {
  27.             plugin.getScoreboard().registerNewTeam("developer");
  28.             admins = plugin.getScoreboard().getTeam("developer");
  29.             admins.setPrefix("§3Dev : ");
  30.         } else {
  31.             admins = plugin.getScoreboard().getTeam("developer");
  32.             admins.setPrefix("§3Dev : ");
  33.         }
  34.         teams.add(developer);
  35.     }
  36.    
  37.     public static void addToTeam(Player player, String team) {
  38.         for(Team allTeams : teams) {
  39.             if(allTeams.hasEntry(player.getName())) allTeams.removeEntry(player.getName());
  40.         }
  41.         switch(team) {
  42.             case "admin":
  43.                 admins.addEntry(player.getName());
  44.                 player.setPlayerListName(admins.getPrefix() + player.getName());
  45.                 player.setDisplayName(admins.getPrefix() + player.getName());
  46.                 player.setCustomName(admins.getPrefix() + player.getName());
  47.                 break;
  48.             case "developer":
  49.                 developer.addEntry(player.getName());
  50.                 player.setPlayerListName(developer.getPrefix() + player.getName());
  51.                 player.setDisplayName(developer.getPrefix() + player.getName());
  52.                 player.setCustomName(developer.getPrefix() + player.getName());
  53.                 break;
  54.         }
  55.     }
  56.    
  57.     public static void removeFromTeams(Player player) {
  58.         for(Team allTeams : teams) {
  59.             if(allTeams.hasEntry(player.getName())) allTeams.removeEntry(player.getName());
  60.         }
  61.         player.setPlayerListName(player.getName());
  62.         player.setDisplayName(player.getName());
  63.         player.setCustomName(player.getName());
  64.     }
  65. }


Diese Methode solltet ihr im PlayerQuitEvent aufrufen, um Fehler zu vermeiden.



5.) Schlusswort und Dankesagung
Ich hoffe ich konnte mnachen von euch mit diesem Tutorial helfen. Es hat mich 2 Stunden gekostet es zu erstellen also seid nicht so streng mit Rechtschreibfehlern ;)

Ich möchte mich auch bei allen bedanken, die mir bis jetzt hier im Forum geholfen haben und vielleicht noch helfen werden.
Nun möchte ich auch helfen und habe deswegen diese Anleitung erstellt.
Mit freundlichen Grüßen

- IcySkill
Benutzeravatar
IcySkill
 
Beiträge: 153
Registriert: Do 12. Feb 2015, 15:23
Wohnort: Baden-Württemberg

Zurück zu Anleitungen

Wer ist online?

Mitglieder in diesem Forum: Bing [Bot] und 4 Gäste