Upstream/MobArena
1
0
Fork 0
mirror of https://github.com/garbagemule/MobArena.git synced 2025-03-31 17:05:59 +02:00
Code Issues Projects Releases Wiki Activity

So, you got a big source code revamp. Big whoop, wanna fight about it?

Browse Source
This commit is contained in:
Garbage Mule 2012-02-24 05:11:06 +01:00
parent e7c66be183
commit 777f6b9b07
193 changed files with 11912 additions and 12726 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.gitignore vendored Normal file
View File

@ -0,0 +1,18 @@
# We don't want to add the Eclipse files.
.project
.classpath
# We can also do without .class files.
*.class
# And we definitely don't need OS files.
.DS_Store*
Thumbs.db
# Exclude some folders
bin/
build/
misc/
lib/
test/
.settings/

BIN
MobArena.jar
View File

Binary file not shown.

2
README → README.md
View File

@ -1,3 +1 @@
(Project is currently on hold until I can find more time.)
Please read the [Wiki](https://github.com/garbagemule/MobArena/wiki/Installing-MobArena) for details on how to set up MobArena, and remember to read the [FAQ](https://github.com/garbagemule/MobArena/wiki/FAQ) before posting questions!

88
build.xml Normal file
View File

@ -0,0 +1,88 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="MobArena" default="dist" basedir=".">
<property name="pluginname" value="MobArena" />
<property name="server" location="D:\General\Java\Minecraft\Minecraft Server\plugins" />
<property name="src" location="src" />
<property name="test" location="test" />
<property name="bin" location="build" />
<property name="lib" location="lib" />
<property name="res" location="resources" />
<path id="classpath">
<fileset dir="${lib}" includes="**/*.jar" />
<fileset dir="${res}" includes="**/*.*" />
<pathelement location="${bin}" />
</path>
<target name="clean">
<delete dir="${bin}" />
</target>
<target name="prepare">
<mkdir dir="${bin}" />
</target>
<!-- Compile the source and put in the bin-folder -->
<target name="build-src" depends="prepare">
<javac target="1.6" source="1.6"
srcdir="${src}" destdir="${bin}"
debug="on" debuglevel="lines,vars,source"
includeantruntime="no"
classpathref="classpath"/>
</target>
<target name="build-src-with-deprecation-check" depends="prepare">
<javac target="1.6" source="1.6"
srcdir="${src}" destdir="${bin}"
debug="on" debuglevel="lines,vars,source"
includeantruntime="no"
classpathref="classpath">
<compilerarg value="-Xlint:deprecation"/>
</javac>
</target>
<target name="build-test" depends="build-src">
<javac target="1.6" source="1.6"
srcdir="${test}" destdir="${bin}"
debug="on" debuglevel="lines,vars,source"
includeantruntime="no" classpathref="classpath" />
</target>
<!-- Build a .jar and copy to server's plugins-folder -->
<target name="dist" depends="build-src">
<delete file="${pluginname}.jar" />
<jar jarfile="${pluginname}.jar">
<!-- Include the class-files (bin) and the resources (res) -->
<fileset dir="${bin}" />
<fileset dir="${res}" />
<!-- Set up the classpath so MobArena can find JDOM if needed -->
<manifest>
<attribute name="Main-Class" value="com.garbagemule.MobArena.MobArena" />
<attribute name="Class-Path" value="plugins/MobArena/lib/jdom.jar MobArena/lib/jdom.jar" />
</manifest>
</jar>
<!-- Copy to server and clean up -->
<copy file="${pluginname}.jar" tofile="${server}/${pluginname}.jar" />
<!--<delete dir="${bin}"/>-->
</target>
<target name="test-config" depends="build-test">
<java classname="org.junit.runner.JUnitCore">
<arg value="garbagemule.mobarena.standard.config.TestNewConfigVsOldConfig" />
<arg value="garbagemule.mobarena.standard.config.TestAdditionalConfigMethods" />
<arg value="garbagemule.mobarena.standard.config.TestConfigCorrectness" />
<classpath refid="classpath" />
</java>
</target>
<target name="test-commands" depends="build-test">
<java classname="org.junit.runner.JUnitCore">
<arg value="garbagemule.mobarena.standard.TestUserCommands" />
<classpath refid="classpath" />
</java>
</target>
<target name="test" depends="test-config,
test-commands" />
</project>

58
language files/cz/announcements.properties Normal file
View File

@ -0,0 +1,58 @@
ARENA_START=Necht zacne masakr!|Arena zacala!
ARENA_END=Arena skoncila.|Arena skoncila.
ARENA_DOES_NOT_EXIST=Takova arena neexistuje. Napis /ma arenas pro seznam aren.|Arena nesla najit.
JOIN_NOT_ENABLED=Areny jsou v tuto chvili vypnute.|Areny nejsou zapnute.
JOIN_IN_OTHER_ARENA=Uz jsi v arene! Musis tuhle opustit nez pujdes do jine.|Jsi v jine arene.
JOIN_ARENA_NOT_ENABLED=Tato arena neni dostupna.|Tato arena je vypnuta.
JOIN_ARENA_NOT_SETUP=Tato arena jeste nebyla nastavena.|Arena neni nastavena.
JOIN_ARENA_EDIT_MODE=Tato arena se zrovna upravuje.|Arena se upravuje.
JOIN_ARENA_PERMISSION=Nemas opravneni ke vstupu do teto areny.|K tomuhle nemas opravneni!
JOIN_FEE_REQUIRED=Insufficient funds. Price: %|Price: %
JOIN_FEE_PAID=Price to join was: %|Paid: %
JOIN_ARENA_IS_RUNNING=Tato arena uz zacala, musis pockat az skonci.|Arena uz probiha, zkus to pozdeji!
JOIN_ALREADY_PLAYING=Uz hrajes!|Uz hrajes!
JOIN_ARG_NEEDED=Musis upresnit arenu. Napis /ma arenas pro seznam aren.
JOIN_TOO_FAR=YJsi prilis daleko od areny aby ses mohl pripojit/sledovat.|Prilis daleko od areny.
JOIN_EMPTY_INV=Musis si nejdriv vyprazdnit inventar.|Vyprazdni si inventar.
JOIN_PLAYER_LIMIT_REACHED=V arene je uz maximum hracu.|Uz nejsou volna mista.
JOIN_STORE_INV_FAIL=Tvuj inventar se nepodarilo ulozit. Zkus to znovu.
JOIN_EXISTING_INV_RESTORED=Tvuj inventar byl navracen.
JOIN_PLAYER_JOINED=Pridal ses do areny. Uzi si to!|Pridal ses do areny.
LEAVE_NOT_PLAYING=Nejsi v arene.|Nejsi v arene.
LEAVE_PLAYER_LEFT=Opustils arenu. Diky za boj!|Opustils arenu.
PLAYER_DIED=% zemrel!|% padl v boji!
SPEC_PLAYER_SPECTATE=Uzi si show!|Uzi si podivanou!
SPEC_NOT_RUNNING=Tato arena neprobiha.|Arena neprobiha.
SPEC_ARG_NEEDED=Musis upresnit arenu. Napis /ma arenas pro seznam aren.|Je pozadovano jmeno areny.
SPEC_EMPTY_INV=Musis si nejdriv vyprazdnit inventar.|Vyprazdni si inventar.
SPEC_ALREADY_PLAYING=Nemuzes byt divakem kdyz jsi bojovnikem!|Vzdyt uz bojujes!
NOT_READY_PLAYERS=Nepripraveni hraci: %
FORCE_START_RUNNING=Arena uz zacala.
FORCE_START_NOT_READY=Boj nemuze zacit, ani jeden hrac neni pripraveny.
FORCE_START_STARTED=Arena zacala, at se vam to libi nebo ne.
FORCE_END_EMPTY=V arene nikdo neni.
FORCE_END_ENDED=Arena ukoncena.
FORCE_END_IDLE=Nebyl jsi dost rychly!
REWARDS_GIVE=Tady jsou vsechyn tve odmeny!
LOBBY_DROP_ITEM=Ne ne ne, tady se o veci delit nesmi!|Veci se tu hazet nesmi.
LOBBY_PLAYER_READY=Jsi pripraven!|Jsi pripraven!
LOBBY_PICK_CLASS=Nejdriv si vyber typ bojovnika!|Vyber si typ bojovnika!
LOBBY_NOT_ENOUGH_PLAYERS=Tak malo bojovniku do areny nemuze. Je potreba alespon % hracu.|Je potreba vice bojovniku!
LOBBY_RIGHT_CLICK=Klikni levym, ne pravym.|Klikni levym.
LOBBY_CLASS_PICKED=Rozhodl ses, ze budes %!|%
LOBBY_CLASS_RANDOM=Na zacatku boje ti bude nahodne pridelen typ bojovnika.
LOBBY_CLASS_PERMISSION=Nemas opravneni byt timto typem bojovnika!|Smula, ale k tomu nemas opravneni!
WARP_TO_ARENA=Nemuzes se objevit v arene uprostred boje!
WARP_FROM_ARENA=Warping not allowed in the arena!
Vlna_DEFAULT=Vlna #%!|Vlna #%!
Vlna_SPECIAL=Vlna #%! [SPECIAL]|Vlna #%! [SPECIAL]
Vlna_SWARM=Vlna #%! [SWARM]|Vlna #%! [SWARM]
Vlna_BOSS=Vlna #%! [BOSS]|Vlna #%! [BOSS]
Vlna_BOSS_ABILITY=Boss pouzil schopnost: %!|Boss: %
Vlna_BOSS_LOW_HEALTH=Boss je temer mrtvy!|Bossovi uz nezbyva moc zivota!
Vlna_REWARD=Ziskal jsi tuto odmenu: %|Byl jsi odmenen: %
MISC_LIST_PLAYERS=Bojovnici stale na nohou: %
MISC_LIST_ARENAS=Dostupne areny: %
MISC_COMMAND_NOT_ALLOWED=Tenhle prikaz v arene pouzit nemuzes!
MISC_NO_ACCESS=K tomuto prikazu nemas pristup.
MISC_NONE=<none>

51
language files/da/announcements.properties Normal file
View File

@ -0,0 +1,51 @@
ARENA_START=Lad massakren begynde!
ARENA_END=Arena slut.
ARENA_DOES_NOT_EXIST=Arenaen findes ikke. Skriv /ma arenas for en liste.
JOIN_PLAYER_JOINED=Du joinede arenaen!
JOIN_NOT_ENABLED=MobArena er ikke aktiveret.
JOIN_IN_OTHER_ARENA=Du er allerede i en arena. Forlad den først.
JOIN_ARENA_NOT_ENABLED=Arenaen er deaktiveret.
JOIN_ARENA_NOT_SETUP=Arenaen er ikke blevet sat op endnu.
JOIN_ARENA_PERMISSION=Du har ikke rettigheder til den arena!
JOIN_FEE_REQUIRED=Du er for fattig. Pris: %
JOIN_FEE_PAID=Prisen for at joine var: %
JOIN_ARENA_IS_RUNNING=Arenaen er allerede startet.
JOIN_ALREADY_PLAYING=Du spiller allerede!
JOIN_ARG_NEEDED=Arenanavn påkrævet. Skriv /ma arenas for en liste.
JOIN_TOO_FAR=Du er for langt fra denne arena til at kunne joine.
JOIN_EMPTY_INV=Du skal tømme dit inventory før du kan joine arenaen.
JOIN_PLAYER_LIMIT_REACHED=Der kan ikke være flere spillere i arenaen.
JOIN_STORE_INV_FAIL=Kunne ikke gemme dit inventory. Prøv igen.
LEAVE_PLAYER_LEFT=Du forlod arenaen.
LEAVE_NOT_PLAYING=Du er ikke i en arena.
PLAYER_DIED=% døde!
SPEC_PLAYER_SPECTATE=Nyd forestillingen!
SPEC_NOT_RUNNING=Arenaen er ikke startet.
SPEC_ARG_NEEDED=Arenanavn påkrævet. Skriv /ma arenas for en liste.
SPEC_EMPTY_INV=Du skal tømme dit inventory først.
SPEC_ALREADY_PLAYING=Du spiller allerede!
NOT_READY_PLAYERS=Ikke klar: %
FORCE_START_STARTED=Arena tvunget til at starte.
FORCE_START_RUNNING=Arenaen er allerede startet.
FORCE_START_NOT_READY=Ingen spillere er klar.
FORCE_END_ENDED=Arena tvunget til at slutte.
FORCE_END_EMPTY=Der er ingen i arenaen.
FORCE_END_IDLE=Du var ikke hurtig nok!
REWARDS_GIVE=Her er alle dine præmier!
LOBBY_CLASS_PICKED=Du har valgt % som din klasse!
LOBBY_CLASS_RANDOM=Du får tildelt en klasse ved arena start.
LOBBY_CLASS_PERMISSION=Du har ikke rettigheder til den klasse!
LOBBY_PLAYER_READY=Du er markeret som klar!
LOBBY_DROP_ITEM=Du kan ikke dele items i lobbyen!
LOBBY_PICK_CLASS=Du skal først vælge en klasse!
LOBBY_RIGHT_CLICK=Slå skiltene; ikke højre-klik.
WARP_TO_ARENA=Du kan ikke warpe til arenaen efter, den er startet.
WARP_FROM_ARENA=Du kan ikke warpe fra arenaen.
WAVE_DEFAULT=Bølge #%!
WAVE_SPECIAL=Bølge #%! [SPECIEL]
WAVE_REWARD=Du har lige vundet en præmie: %
MISC_LIST_ARENAS=Tilgængelige arenaer: %
MISC_LIST_PLAYERS=Levende spillere: %
MISC_COMMAND_NOT_ALLOWED=Du kan ikke bruge den kommando i arenaen.
MISC_NO_ACCESS=Du har ikke adgang til den kommando.
MISC_NONE=<ingen>

53
language files/de/announcements.properties Normal file
View File

@ -0,0 +1,53 @@
ARENA_START=Lasst die Spiele beginnen
ARENA_END=Arena beendet
ARENA_DOES_NOT_EXIST=Diese Arena existiert nicht tippe /ma um alle Arenen anzuzeigen.
JOIN_PLAYER_JOINED=Du bist nun in der Arena.
Viel Spass!
JOIN_NOT_ENABLED=Die Mobarena wurde deaktiviert
JOIN_IN_OTHER_ARENA=Du bist momentan in einer Arena, verlasse diese jetzt.
JOIN_ARENA_NOT_ENABLED=Diese Arena ist nicht aktiviert.
JOIN_ARENA_NOT_SETUP=Diese Arena wurde noch nicht eingerichtet.
JOIN_ARENA_PERMISSION=Du bist nicht berechtigt diese Arena zu betretten.
JOIN_FEE_REQUIRED=Ungenügender Kontostand. Preis: %
JOIN_FEE_PAID=Der Preis um bei zu tretten: %
JOIN_ARENA_IS_RUNNING=Der Kampf in dieser Arena ist bereits zu gange.
JOIN_ALREADY_PLAYING=Du spielst bereits!
JOIN_ARG_NEEDED=Du must den Namen der Arena eingeben. Gib /ma arenas ein für eine Liste.
JOIN_TOO_FAR=Du bist zu weit weg um bei zu tretten oder zu zuschauen.
JOIN_EMPTY_INV=Du must dein Inventar leeren um der Arena bei zu tretten.
JOIN_PLAYER_LIMIT_REACHED=Die Spieler Limite ist erreicht.
JOIN_STORE_INV_FAIL=Momentan nicht möglich dein Inventar zu speichern. Probiere es noch einmal.
LEAVE_PLAYER_LEFT=Du hast die Arena verlassen. Vielen Dank fürs Spielen!
LEAVE_NOT_PLAYING=Du kannst die Arena nicht verlassen wenn du nich in der Arena bist! Du Depp.
PLAYER_DIED=% ist gestorben!
SPEC_PLAYER_SPECTATE=Amüsier dich am Kampf!
SPEC_NOT_RUNNING=Diese Arena läuft im Moment nicht.
SPEC_ARG_NEEDED=Du must den Namen der Arena eingeben. Gib /ma arenas ein für eine Liste.
SPEC_EMPTY_INV=Du must dein Inventar leeren um der Arena bei zu tretten!
SPEC_ALREADY_PLAYING=Du kannst dir nicht selber zuschauen wie du kämpfst!
NOT_READY_PLAYERS=Noch nicht bereit sind: %
FORCE_START_STARTED=Gezwungener Start des Kampfes.
FORCE_START_RUNNING=Die Arena wurde bereits gestartet.
FORCE_START_NOT_READY=Kann den Start des Kampfes nicht erzwingen, keine Spieler vorhanden.
FORCE_END_ENDED=Gezwunges Kampf Ende.
FORCE_END_EMPTY=Niemand ist in der Arena.
FORCE_END_IDLE=Du warst nicht schnell genug!
REWARDS_GIVE=Hier sind deine Preise!
LOBBY_CLASS_PICKED=Du hast % als deine Kampfklasse gewählt!
LOBBY_CLASS_RANDOM=Du wirst beim Start des Spiels einer zufälligen Kampfklasse zugeortnet.
LOBBY_CLASS_PERMISSION=Du hast keine Berechtigung diese Kampfklasse zu wählen!
LOBBY_NOT_ENOUGH_PLAYERS=Nicht genung Spieler um den Kampf zu starten. Es benötigt mindestens % Spieler.
LOBBY_PLAYER_READY=Du hast dich als bereit gemeldet!
LOBBY_DROP_ITEM=Du darfts momentant deine Tools nicht an andere weitergeben!
LOBBY_PICK_CLASS=Du must zuerst eine Kampfklasse auswählen!
LOBBY_RIGHT_CLICK=Du must das Schild schlagen. Nicht rechtsklicken.
WARP_TO_ARENA=Du kannst dich jetzt nich in die Arena teleportieren!
WARP_FROM_ARENA=Du darfst dich jetzt nicht aus der Arena teleportiern!
WAVE_DEFAULT=Sei bereit für die %. Welle!
WAVE_SPECIAL=Mach dich für eine spezielle %. Welle bereit!
WAVE_REWARD=Du hast einen Preis: %
MISC_LIST_ARENAS=Verfügbare Arenas: %
MISC_LIST_PLAYERS=Live Spieler: %
MISC_COMMAND_NOT_ALLOWED=Du darfst diesen Befehl nicht in der Arena benutzen!
MISC_NO_ACCESS=Du hast keinen Zugriff auf diesen Befehl.
MISC_NONE=<none>

51
language files/fr/announcements.properties Normal file
View File

@ -0,0 +1,51 @@
ARENA_START=Que le massacre commence !
ARENA_END=L'arène est terminée.
ARENA_DOES_NOT_EXIST=Cette arène n'existe pas. Entrez "/ma arenas" pour la liste.
JOIN_PLAYER_JOINED=Vous avez rejoint l'arène. Prennez plaisir !
JOIN_NOT_ENABLED=MobArena n'est pas actif.
JOIN_IN_OTHER_ARENA=Vous êtes déjà dans l'arène! Quittez-la avant.
JOIN_ARENA_NOT_ENABLED=Cetta arène n'est pas active.
JOIN_ARENA_NOT_SETUP=Cette arène n'a pas encore été configurée.
JOIN_ARENA_PERMISSION=Vous n'avez pas la permission pour rejoindre cette arène.
JOIN_FEE_REQUIRED=Pas assez d'argent. Prix: %
JOIN_FEE_PAID=Le prix pour rejoindre était de: %
JOIN_ARENA_IS_RUNNING=L'arène est déjà occupée.
JOIN_ALREADY_PLAYING=Vous êtes déjà en train de jouer.
JOIN_ARG_NEEDED=Vous devez spécifier une arène. Entrez "/ma arenas" pour la liste.
JOIN_TOO_FAR=Vous êtes trop loins de l'arène pour pouvoir joindre en tant que joueur ou specateur.
JOIN_EMPTY_INV=Vous devez vider votre inventaire afin de joindre l'arène.
JOIN_PLAYER_LIMIT_REACHED=La limite de joueur pour cette arène a été atteinte.
JOIN_STORE_INV_FAIL=La sauvegarde de l'inventaire a échouée. Essayez encore.
LEAVE_PLAYER_LEFT=Vous avez quitté l'arène. Merci d'avoir joué !
LEAVE_NOT_PLAYING=Vous n'êtes pas dans l'arène.
PLAYER_DIED=% est mort !
SPEC_PLAYER_SPECTATE=Profitez bien du spectacle !
SPEC_NOT_RUNNING=Cette arène n'est pas en cours.
SPEC_ARG_NEEDED=Vous devez spécifier une arène. Entrez "/ma arenas" pour la liste.
SPEC_EMPTY_INV=Vous devez vider votre inventaire.
SPEC_ALREADY_PLAYING=Vous ne pouvez pas être spectateur en tant que joueur de l'arène !
NOT_READY_PLAYERS=Non prêt: %
FORCE_START_STARTED=Début forcé de l'arène.
FORCE_START_RUNNING=L'arène a commencée.
FORCE_START_NOT_READY=Ne peut pas forcer le début, il n'y a pas de joueurs prêts.
FORCE_END_ENDED=Fin forcée de l'arène.
FORCE_END_EMPTY=Il n'y a personne dans l'arène.
FORCE_END_IDLE=Vous n'avez pas été assez rapide !
REWARDS_GIVE=Voici vos récompenses !
LOBBY_CLASS_PICKED=Vous avez choisi % comme classe !
LOBBY_CLASS_RANDOM=Une classe aléatoire va vous être attribuée.
LOBBY_CLASS_PERMISSION=Vous n'avez pas les permissions pour utiliser cette classe !
LOBBY_PLAYER_READY=Vous avez été marqué comme prêt !
LOBBY_DROP_ITEM=Pas de partage avant le début de l'arène !
LOBBY_PICK_CLASS=Vous devez d'abord choisir une classe !
LOBBY_RIGHT_CLICK=Vous devez frapper le panneau, pas cliquer du droit dessus.
WARP_TO_ARENA=Vous ne pouvez pas vous téléporter à l'arène pendant la bataille !
WARP_FROM_ARENA=La téléportation est interdite dans l'arène !
WAVE_DEFAULT=Soyez prêt pour la vague #% !
WAVE_SPECIAL=Soyez prêt pour la vague #% ! [SPECIALE]
WAVE_REWARD=Vous avez gagné une récompense: %
MISC_LIST_ARENAS=Les arènes disponibles: %
MISC_LIST_PLAYERS=Les joueurs en live: %
MISC_COMMAND_NOT_ALLOWED=Vous ne pouvez pas utiliser cette commande dans l'arène !
MISC_NO_ACCESS=Vous n'avez pas accès à cette commande.
MISC_NONE=<rien>

52
language files/nl/announcements.properties Normal file
View File

@ -0,0 +1,52 @@
ARENA_START=Laat de slachting beginnen!
ARENA_END=Arena voltooid.
ARENA_DOES_NOT_EXIST=Die arena bestaat niet. Typ /ma arenas voor een lijst.
JOIN_PLAYER_JOINED=U heeft toegetreden tot deze arena. Veel plezier!
JOIN_NOT_ENABLED=MobArena staat niet aan.
JOIN_IN_OTHER_ARENA=U bevindt zich al in een arena! Vertaal die eerst.
JOIN_ARENA_NOT_ENABLED=Deze arena staat niet aan.
JOIN_ARENA_PERMISSION=U heeft geen permissie om deze arena toe te treden.
JOIN_ARENA_NOT_SETUP=Deze arena is nog niet ingesteld.
JOIN_FEE_REQUIRED=Onvoldoende geld. Prijs: %
JOIN_FEE_PAID=Prijs om toe te treden is: %
JOIN_ARENA_IS_RUNNING=Deze arena is al bezig.
JOIN_ALREADY_PLAYING=U bent al aan het spelen!
JOIN_ARG_NEEDED=U moet een arena specificeren. Typ /ma arenas voor een lijst.
JOIN_TOO_FAR=U bent te ver weg van de arena om toe te treden/toe te kijken.
JOIN_EMPTY_INV=U moet uw inventaris eerst legen om toe te treden tot deze arena.
JOIN_PLAYER_LIMIT_REACHED=De speler limiet van deze arena is berijkt.
JOIN_STORE_INV_FAIL=Inventaris opslaan mislukt. Probeer het opnieuw.
LEAVE_PLAYER_LEFT=U verliet de arena. Bedankt voor het spelen!
LEAVE_NOT_PLAYING=U bent niet in de arena.
PLAYER_DIED=% ging dood!
SPEC_PLAYER_SPECTATE=Geniet van de show!
SPEC_NOT_RUNNING=Deze arena is niet actief.
SPEC_ARG_NEEDED=U moet een arena specificeren. Typ /ma arenas voor een lijst.
SPEC_EMPTY_INV=Leeg uw inventaris eerst!
SPEC_ALREADY_PLAYING=Kan niet toekijken als je in de arena zit!
NOT_READY_PLAYERS=Niet klaar: %
FORCE_START_STARTED=Geforceerd arena te starten.
FORCE_START_RUNNING=Arena is al begonnen.
FORCE_START_NOT_READY=Kan arena niet geforceerd starten, geen spelers zijn klaar.
FORCE_END_ENDED=Geforceerd arena te beëindigen.
FORCE_END_EMPTY=Niemand is in deze arena.
FORCE_END_IDLE=U was niet snel genoeg!
REWARDS_GIVE=Hier zijn al uw beloningen!
LOBBY_CLASS_PICKED=U heeft % gekozen als uw klasse!
LOBBY_CLASS_RANDOM=U krijgt een willekeurige klasse als de arena start.
LOBBY_CLASS_PERMISSION=U heeft geen permissie om deze klasse te gebruiken!
LOBBY_NOT_ENOUGH_PLAYERS=Niet genoeg spelers om te beginnen. Op zijn minst % spelers nodig.
LOBBY_PLAYER_READY=U bent gemarkeerd als klaar!
LOBBY_DROP_ITEM=Delen niet toegestaan ​​op dit moment!
LOBBY_PICK_CLASS=U moet eerst een klasse kiezen!
LOBBY_RIGHT_CLICK=Sla het bord. Geen klik met de rechtermuisknop.
WARP_TO_ARENA=Kan niet teleporteren naar een arena tijdens een gevecht!
WARP_FROM_ARENA=Teleporteren niet toegestaan ​​in de arena!
WAVE_DEFAULT=Maak U klaar voor golf #%!
WAVE_SPECIAL=Maak U klaar voor golf #%! [SPECIAAL]
WAVE_REWARD=U heeft zojuist een beloning verdiend: %
MISC_LIST_ARENAS=Beschikbare arenas: %
MISC_LIST_PLAYERS=Live spelers: %
MISC_COMMAND_NOT_ALLOWED=U kan dit commando niet gebruiken in de arena!
MISC_NO_ACCESS=U heeft geen toegang tot dit commando.
MISC_NONE=<geen>

51
language files/pirate/announcements.properties Normal file
View File

@ -0,0 +1,51 @@
ARENA_START=Hearts alive, men!
ARENA_END=Land ho!
ARENA_DOES_NOT_EXIST=Thar be no ship by that name!
JOIN_PLAYER_JOINED=Ahoy, matey!
JOIN_NOT_ENABLED=We be swabbing down the decks on all ships, matey.
JOIN_IN_OTHER_ARENA=Ye're already at sea, scallywag!
JOIN_ARENA_NOT_ENABLED=We be swabbing down the decks on this ship, matey.
JOIN_ARENA_NOT_SETUP=Arrrgh! We be missing the top sail!
JOIN_ARENA_PERMISSION=Arrgh! Ye can't board this ship, scurvy dog!
JOIN_FEE_REQUIRED=Ye don't own enough doubloons, matey! Price: %
JOIN_FEE_PAID=Booty ye gave up to join: %
JOIN_ARENA_IS_RUNNING=That ship has sailed, landlubber!
JOIN_ALREADY_PLAYING=Ye be aboard already, ye scurvy dog!
JOIN_ARG_NEEDED=Which ship are ye boarding? Type /ma arenas for a list, arrgh!
JOIN_TOO_FAR=Ye be too far from the docks, landlubber!
JOIN_EMPTY_INV=Throw ye belongings overboard, scallywag!
JOIN_PLAYER_LIMIT_REACHED=Thar be too many men aboard this ship already, landlubber!
JOIN_STORE_INV_FAIL=Ye belongings didn't fit in the storage deck, arrgh!
LEAVE_PLAYER_LEFT=Ye abandonned the ship! Arrrgh!
LEAVE_NOT_PLAYING=Ye're already on land, matey!
PLAYER_DIED=% walked the plank!
SPEC_PLAYER_SPECTATE=Welcome to the Crow's Nest! Grab ye spyglass!
SPEC_NOT_RUNNING=Thar be no one aboard that ship!
SPEC_ARG_NEEDED=Which ship are ye boarding? Type /ma arenas for a list, arrgh!
SPEC_EMPTY_INV=Throw ye belongings overboard, scallywag!
SPEC_ALREADY_PLAYING=Ye don't need ye spyglass aboard this ship, harr!
NOT_READY_PLAYERS=Landlubbers: %
FORCE_START_STARTED=Set sail!
FORCE_START_RUNNING=The ship has already set sail!
FORCE_START_NOT_READY=Thar be no scurvy dogs ready to set sail!
FORCE_END_ENDED=Forced the men to walk the plank!
FORCE_END_EMPTY=Thar be no one aboard the ship!
FORCE_END_IDLE=Arrrgh! Too slow, matey!
REWARDS_GIVE=Here's ye booty, seadog!
LOBBY_CLASS_PICKED=Ye be the %!
LOBBY_CLASS_RANDOM=
LOBBY_CLASS_PERMISSION=Ye can't use that cutlass, scurvy dog!
LOBBY_PLAYER_READY=Ready to sail! Arrrgh!
LOBBY_DROP_ITEM=Don't be sharing ye rum yet, scallywag!
LOBBY_PICK_CLASS=Grab ye cutlass first, matey!
LOBBY_RIGHT_CLICK=Ye can't be right-clickin', landlubber.
WARP_TO_ARENA=Ye can't board this ship, wench!
WARP_FROM_ARENA=Walk the plank if ye want to leave, arrrgh!
WAVE_DEFAULT=Wave %: Blow them all down!
WAVE_SPECIAL=Wave %: Thar she blows!
WAVE_REWARD=Ye earned yerself some booty: %
MISC_LIST_ARENAS=Ships: %
MISC_LIST_PLAYERS=Buccaneers: %
MISC_COMMAND_NOT_ALLOWED=Ye can't be usin' that command on the ship, landlubber!
MISC_NO_ACCESS=Only the captain uses these commands, wench!
MISC_NONE=<none>

67
resources/plugin.yml
View File

@ -1,7 +1,8 @@
name: MobArena
author: garbagemule
main: com.garbagemule.MobArena.MobArena
version: 0.94.4.4
softdepend: [Spout,Permissions,MultiVerse,XcraftGate,Towny,Heroes,MagicSpells]
version: 0.94.4.49
softdepend: [Spout,MultiVerse,XcraftGate,Towny,Heroes,MagicSpells,Vault]
commands:
ma:
description: Base command for MobArena
@ -18,18 +19,20 @@ commands:
http://pastebin.com, and then paste the link
in the IRC or on the forums.
permissions:
mobarena.use:
description: Gives access to usage commands
default: true
children:
mobarena.use.join: true
mobarena.use.spec: true
mobarena.use.leave: true
mobarena.use.join:
description: Join command
default: true
mobarena.use.spec:
description: Spec command
default: true
mobarena.use.leave:
description: Leave command
default: true
mobarena.use.arenalist:
description: Arena list command
default: true
mobarena.use.playerlist:
description: Arena list command
default: true
mobarena.admin:
@ -39,9 +42,8 @@ permissions:
mobarena.admin.enable: true
mobarena.admin.kick: true
mobarena.admin.restore: true
mobarena.admin.force.end: true
mobarena.admin.force.start: true
mobarena.admin.config.reload: true
mobarena.admin.force: true
mobarena.admin.teleport: true
mobarena.admin.enable:
description: Enable and disable MobArena and/or arenas.
default: false
@ -51,14 +53,11 @@ permissions:
mobarena.admin.restore:
description: Restore a player's inventory.
default: false
mobarena.admin.force.end:
description: Force end an arena.
mobarena.admin.force:
description: Force start or end an arena.
default: false
mobarena.admin.force.start:
description: Force start an arena.
default: false
mobarena.admin.config.reload:
description: Reload the config-file.
mobarena.admin.teleport:
description: Immune to teleport blocking rules.
default: false
mobarena.setup:
@ -68,7 +67,7 @@ permissions:
mobarena.setup.arena: true
mobarena.setup.setarena: true
mobarena.setup.addarena: true
mobarena.setup.delarena: true
mobarena.setup.removearena: true
mobarena.setup.protect: true
mobarena.setup.editarena: true
mobarena.setup.setregion: true
@ -78,13 +77,11 @@ permissions:
mobarena.setup.expandlobbyregion: true
mobarena.setup.setwarp: true
mobarena.setup.spawnpoints: true
mobarena.setup.addspawn: true
mobarena.setup.delspawn: true
mobarena.setup.containers: true
mobarena.setup.addcontainer: true
mobarena.setup.delcontainer: true
mobarena.setup.leaderboards: true
mobarena.setup.checkdata: true
mobarena.setup.classes: true
mobarena.setup.config: true
mobarena.setup.autogenerate: true
mobarena.setup.autodegenerate: true
mobarena.setup.arena:
@ -96,8 +93,8 @@ permissions:
mobarena.setup.addarena:
description: Add a new arena node.
default: false
mobarena.setup.delarena:
description: Delete an arena.
mobarena.setup.removearena:
description: Remove an arena.
default: false
mobarena.setup.protect:
description: Turn arena protection on/off.
@ -126,27 +123,21 @@ permissions:
mobarena.setup.spawnpoints:
description: List all spawnpoints.
default: false
mobarena.setup.addspawn:
description: Add a new spawnpoint.
default: false
mobarena.setup.delspawn:
description: Delete a spawnpoint.
default: false
mobarena.setup.containers:
description: List all containers.
default: false
mobarena.setup.addcontainer:
description: Add a new container.
default: false
mobarena.setup.delcontainer:
description: Delete a container.
default: false
mobarena.setup.leaderboards:
description: Set up leaderboards.
default: false
mobarena.setup.checkdata:
description: Check which points need to be set up.
default: false
mobarena.setup.classes:
description: Allows setting up classes from in-game
default: false
mobarena.setup.config:
description: Save or reload the config-file
default: false
mobarena.setup.autogenerate:
description: Auto-generate an arena.
default: false

15
resources/res/classes.yml Normal file
View File

@ -0,0 +1,15 @@
Knight:
items: diamond_sword, potion:8197:3
armor: 306,307,308,309
Tank:
items: iron_sword, potion:8229:2
armor: 310,311,312,313
Archer:
items: wood_sword, bow, arrow:256, potion:8197:3, bone
armor: 298,299,300,301
Chemist:
items: stone_sword, potion:16428:30, potion:16388:8, potion:16389:20, potion:8197:3, potion:8226:1
armor: 314,315,316,317
Oddjob:
items: stone_sword, flint_and_steel, netherrack:2, tnt:4, potion:8197:3
armor: 298,299,300,301

117
resources/res/config.yml
View File

@ -1,113 +1,4 @@
### MobArena Configuration File
### Please visit the MobArena Wiki here: http://goo.gl/F5TTc for more details
### on how to set up this file.
### Note that you CAN'T use tabs in this file! Always use spaces!
### GLOBAL SETTINGS
# These settings are arena-independent and count in all arenas. Note that if
# enabled: false in the global settings, MobArena is disabled globally, and
# arena-specific enabled-values do not matter. If true, however, the per-arena
# enabled-values count.
global-settings:
enabled: true
allowed-commands: /list, /pl
update-notification: true
### CLASS SETUP
# Items can be written as either their data value (numbers) or their Material
# type (names); check the Wiki for links to lists of both.
# The notation is <item>:<amount>. If no amount is given, 1 is assumed. Sub-
# types can be created
# Item SUBTYPES (wool/dye colors) are written as <item>:<subtype>:<amount>,
# but here, the amount is REQUIRED, even if it is just 1.
# Note: If you want to specify only one item, but apostrophes around that one
# item, e.g.: items: '278'
# Note: For every bone a class has, one PET WOLF will spawn upon arena start,
# which will assist the player in the arena session.
classes:
Knight:
items: diamond_sword, grilled_pork:2
armor: 306,307,308,309
Tank:
items: iron_sword, grilled_pork:3, apple
armor: 310,311,312,313
Archer:
items: wood_sword, bow, arrow:256, grilled_pork, bone
armor: 298,299,300,301
Chef:
items: stone_sword, bread:6, grilled_pork:4, mushroom_soup, cake:5
armor: 314,315,316,317
Oddjob:
items: stone_sword, flint_and_steel, netherrack:2, tnt:4, pork:3
armor: 298,299,300,301
### ARENA SETUP
# The arena setup is split into 4 different sections per arena: settings,
# waves, rewards and coords (not shown until coords are set up).
# Please refer to the Wiki for descriptions of all these settings.
# Note: The REWARDS use the same notation as the items in the CLASS SETUP
# section. However, only -one- item from the list is picked (at random) when
# the rewards are given.
arenas:
default:
settings:
world: ''
enabled: true
protect: true
entry-fee: ''
logging: true
clear-wave-before-next: false
detonate-creepers: false
detonate-damage: false
lightning: true
auto-equip-armor: true
force-restore: false
soft-restore: false
soft-restore-drops: false
require-empty-inv-join: false
require-empty-inv-spec: false
hellhounds: false
pvp-enabled: false
monster-infight: false
allow-teleporting: false
spectate-on-death: true
share-items-in-arena: true
min-players: 0
max-players: 0
max-join-distance: 0
repair-delay: 5
first-wave-delay: 5
wave-interval: 20
special-modulo: 4
max-idle-time: 0
waves:
recurrent:
def1:
type: default
priority: 1
frequency: 1
monsters:
zombies: 10
skeletons: 10
spiders: 10
creepers: 10
wolves: 10
spec1:
type: special
priority: 2
frequency: 4
monsters:
powered-creepers: 10
zombie-pigmen: 10
angry-wolves: 10
humans: 10
rewards:
waves:
every:
'3': feather, bone, stick
'5': dirt:4, gravel:4, stone:4
'10': iron_ingot:10, gold_ingot:8
after:
'7': minecart, storage_minecart, powered_minecart
'13': iron_sword, iron_pickaxe, iron_spade
'16': diamond_sword
# Layout
global-settings: {}
classes: {}
arenas: {}

3
resources/res/global-settings.yml Normal file
View File

@ -0,0 +1,3 @@
enabled: true
allowed-commands: /list, /pl
update-notification: true

7
resources/res/magicspells.yml
View File

@ -1,17 +1,16 @@
# MobArena disabled MagicSpells spells
# MobArena disabled MagicSpells spells
# Use this file to disable the MagicSpells spells you don't want your players
# to use during arena sessions. Make sure to put a hyphen (-) before every
# spell, and try to keep the indentation proper.
# Spells that will be disabled for the entire arena session.
disabled-spells:
- carpet
- blink
# Spells that will be disabled only while a boss is present.
disabled-only-on-bosses:
disabled-on-bosses:
- purge
# Spells that will be disabled only during swarm waves.
disabled-only-on-swarms:
disabled-on-swarms:
- purge

9
resources/res/rewards.yml Normal file
View File

@ -0,0 +1,9 @@
waves:
every:
'3': feather, bone, stick
'5': dirt:4, gravel:4, stone:4
'10': iron_ingot:10, gold_ingot:8
after:
'7': minecart, storage_minecart, powered_minecart
'13': iron_sword, iron_pickaxe, iron_spade
'16': diamond_sword

33
resources/res/settings.yml Normal file
View File

@ -0,0 +1,33 @@
world: ''
enabled: true
protect: true
logging: true
entry-fee: ''
clear-wave-before-next: false
clear-boss-before-next: false
lightning: true
auto-equip-armor: true
soft-restore: false
soft-restore-drops: false
require-empty-inv-join: false
require-empty-inv-spec: false
hellhounds: false
pvp-enabled: false
monster-infight: false
allow-teleporting: false
spectate-on-death: true
auto-respawn: true
share-items-in-arena: true
min-players: 0
max-players: 0
max-join-distance: 0
first-wave-delay: 5
wave-interval: 15
final-wave: 0
monster-limit: 100
monster-exp: false
keep-exp: true
food-regen: false
lock-food-level: true
spout-class-select: false
player-time-in-arena: world

32
resources/res/waves.yml Normal file
View File

@ -0,0 +1,32 @@
recurrent:
def1:
type: default
priority: 1
frequency: 1
monsters:
zombies: 10
skeletons: 10
spiders: 10
creepers: 10
wolves: 10
spec1:
type: special
priority: 2
frequency: 4
monsters:
powered-creepers: 10
zombie-pigmen: 10
angry-wolves: 10
blazes: 10
single:
swarm1:
type: swarm
wave: 6
monster: slime
amount: low
boss1:
type: boss
wave: 10
monster: cave_spider
health: high
abilities: arrows, root-target, throw-nearby

302
src/com/garbagemule/MobArena/Arena.java
View File

@ -1,302 +0,0 @@
package com.garbagemule.MobArena;
import java.util.*;
import java.util.concurrent.PriorityBlockingQueue;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Wolf;
import org.bukkit.inventory.ItemStack;
import org.bukkit.permissions.PermissionAttachment;
//import org.bukkit.util.config.Configuration;
import com.garbagemule.MobArena.leaderboards.Leaderboard;
import com.garbagemule.MobArena.repairable.Repairable;
import com.garbagemule.MobArena.repairable.RepairableComparator;
import com.garbagemule.MobArena.util.Config;
import com.garbagemule.MobArena.waves.BossWave;
import com.garbagemule.MobArena.waves.Wave;
public abstract class Arena
{
private MobArena plugin;
// Setup fields
protected String name;
protected World world;
protected boolean enabled, protect, running, setup, lobbySetup, autoEquip, forceRestore, softRestore, softRestoreDrops, emptyInvJoin, emptyInvSpec, pvp, monsterInfight, allowWarp;
protected boolean edit, waveClear, detCreepers, detDamage, lightning, hellhounds, specOnDeath, shareInArena, spoutSelect;
protected Location p1, p2, l1, l2, arenaLoc, lobbyLoc, spectatorLoc;
protected Map<String,Location> spawnpoints, spawnpointsBoss, containers;
protected String logging;
// Wave/reward/entryfee fields
protected int spawnTaskId, sheepTaskId, waveDelay, waveInterval, specialModulo, spawnMonstersInt, maxIdleTime, finalWave;
protected MASpawnThread spawnThread;
protected Map<Integer,List<ItemStack>> everyWaveMap, afterWaveMap;
protected Map<Player,String> classMap;
protected Map<String,List<ItemStack>> classItems, classArmor;
protected Map<String,Map<String,Boolean>> classPerms;
protected Map<Player,PermissionAttachment> attachments;
protected List<ItemStack> entryFee;
// Player sets
protected Set<Player> arenaPlayers, lobbyPlayers, readyPlayers, specPlayers;
// Wave stuff
protected TreeSet<Wave> singleWaves, singleWavesInstance;
protected TreeSet<Wave> recurrentWaves;
protected BossWave bossWave;
protected Wave currentWave;
// Arena sets/maps
protected Set<Player> hasPaid, rewardedPlayers, notifyPlayers, randoms;
protected Set<LivingEntity> monsters, explodingSheep, plaguedPigs, madCows;
protected Set<Block> blocks;
protected Set<Wolf> pets;
protected Map<Player,Integer> petMap;
protected LinkedList<Repairable> repairables, containables;
// Spawn overriding
protected int spawnMonsters;
protected boolean allowMonsters, allowAnimals;
// Other settings
protected int minPlayers, maxPlayers, joinDistance;
protected Set<String> classes = new HashSet<String>();
protected Map<Player,Location> locations = new HashMap<Player,Location>();
protected Map<Player,Integer> healthMap = new HashMap<Player,Integer>();
protected Map<Player,Integer> hungerMap = new HashMap<Player,Integer>();
protected Map<Player,GameMode> modeMap = new HashMap<Player,GameMode>();
// Logging
protected ArenaLog log;
protected Map<Player,ArenaPlayer> arenaPlayerMap;
protected Leaderboard leaderboard;
protected MAListener eventListener;
protected PriorityBlockingQueue<Repairable> repairQueue;
public Arena() {
}
/**
* Primary constructor. Requires a name and a world.
*/
public Arena(String name, World world)
{
if (world == null)
throw new NullPointerException("[MobArena] ERROR! World for arena '" + name + "' does not exist!");
this.name = name;
this.world = world;
plugin = (MobArena) Bukkit.getServer().getPluginManager().getPlugin("MobArena");
arenaPlayers = new HashSet<Player>();
lobbyPlayers = new HashSet<Player>();
notifyPlayers = new HashSet<Player>();
readyPlayers = new HashSet<Player>();
specPlayers = new HashSet<Player>();
rewardedPlayers = new HashSet<Player>();
hasPaid = new HashSet<Player>();
monsters = new HashSet<LivingEntity>();
explodingSheep = new HashSet<LivingEntity>();
plaguedPigs = new HashSet<LivingEntity>();
madCows = new HashSet<LivingEntity>();
blocks = new HashSet<Block>();
pets = new HashSet<Wolf>();
petMap = new HashMap<Player,Integer>();
classMap = new HashMap<Player,String>();
randoms = new HashSet<Player>();
repairables = new LinkedList<Repairable>();
containables = new LinkedList<Repairable>();
attachments = new HashMap<Player,PermissionAttachment>();
arenaPlayerMap = new HashMap<Player,ArenaPlayer>();
running = false;
edit = false;
allowMonsters = world.getAllowMonsters();
allowAnimals = world.getAllowAnimals();
spawnMonsters = MAUtils.getSpawnMonsters(world);
eventListener = new MAListener(this, plugin);
repairQueue = new PriorityBlockingQueue<Repairable>(100, new RepairableComparator());
}
public abstract boolean startArena();
public abstract boolean endArena();
public abstract void forceStart();
public abstract void forceEnd();
public abstract void playerJoin(Player p, Location loc);
public abstract void playerReady(Player p);
public abstract void playerLeave(Player p);
public abstract void playerDeath(Player p);
public abstract void playerSpec(Player p, Location loc);
public abstract void playerKill(Player p);
public abstract void restoreInvAndGiveRewardsDelayed(final Player p);
public abstract void restoreInvAndGiveRewards(final Player p);
public abstract void storePlayerData(Player p, Location loc);
public abstract void storeContainerContents();
public abstract void restoreContainerContents();
public abstract void movePlayerToLobby(Player p);
public abstract void movePlayerToSpec(Player p);
public abstract void movePlayerToEntry(Player p);
public abstract void repairBlocks();
public abstract void queueRepairable(Repairable r);
/*////////////////////////////////////////////////////////////////////
//
// Items & Cleanup
//
////////////////////////////////////////////////////////////////////*/
public abstract void assignClass(Player p, String className);
public abstract void assignRandomClass(Player p);
public abstract void assignClassPermissions(Player p);
public abstract void removeClassPermissions(Player p);
/*////////////////////////////////////////////////////////////////////
//
// Initialization & Checks
//
////////////////////////////////////////////////////////////////////*/
public abstract void load(Config config);
public abstract void restoreRegion();
public abstract void serializeConfig();
public abstract void deserializeConfig();
public abstract boolean serializeRegion();
public abstract boolean deserializeRegion();
/**
* Check if a location is inside of the cuboid region
* that p1 and p2 span.
*/
public abstract boolean inRegion(Location loc);
/**
* Check if a location is inside of the arena region, expanded
* by 'radius' blocks. Used with explosions.
*/
public abstract boolean inRegionRadius(Location loc, int radius);
/*////////////////////////////////////////////////////////////////////
//
// Getters & Misc
//
////////////////////////////////////////////////////////////////////*/
public abstract boolean inArena(Player p);
public abstract boolean inLobby(Player p);
public abstract boolean isEnabled();
public abstract boolean isRunning();
public abstract boolean isPvpEnabled();
public abstract boolean isLightningEnabled();
public abstract boolean isBossWave();
public abstract String configName();
public abstract String arenaName();
public abstract MobArena getPlugin();
public abstract World getWorld();
public abstract Wave getWave();
public abstract void setWave(Wave wave);
public abstract void setBossWave(BossWave bossWave);
public abstract Set<String> getClasses();
public abstract List<Location> getAllSpawnpoints();
public abstract List<Location> getSpawnpoints();
public abstract Location getBossSpawnpoint();
public abstract int getPlayerCount();
public abstract void addBlock(Block b);
public abstract void addMonster(LivingEntity e);
public abstract void addExplodingSheep(LivingEntity e);
public abstract List<Player> getAllPlayers();
public abstract List<Player> getLivingPlayers();
public abstract Set<Player> getArenaPlayers();
public abstract Collection<ArenaPlayer> getArenaPlayerSet();
public abstract List<ArenaPlayerStatistics> getArenaPlayerStatistics(Comparator<ArenaPlayerStatistics> comparator);
public abstract List<Player> getNonreadyPlayers();
public abstract Set<LivingEntity> getMonsters();
public abstract Set<Wolf> getPets();
public abstract void resetIdleTimer();
public abstract void addTrunkAndLeaves(Block b);
public abstract boolean canAfford(Player p);
public abstract boolean takeFee(Player p);
public abstract boolean canJoin(Player p);
public abstract boolean canSpec(Player p);
}

283
src/com/garbagemule/MobArena/ArenaClass.java Normal file
View File

@ -0,0 +1,283 @@
package com.garbagemule.MobArena;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.permissions.PermissionAttachment;
public class ArenaClass
{
private String name;
private ItemStack helmet, chestplate, leggings, boots;
private List<ItemStack> items, armor;
private Map<String,Boolean> perms;
private int pets;
/**
* Create a new, empty arena class with the given name.
* @param name the class name
*/
public ArenaClass(String name) {
this.name = name;
this.items = new ArrayList<ItemStack>();
this.armor = new ArrayList<ItemStack>(4);
this.perms = new HashMap<String,Boolean>();
this.pets = 0;
}
/**
* Get the name of the arena class.
* @return the class name
*/
public String getName() {
return name;
}
/**
* Get the Material type of the first item in the items list.
* If the items list is empty, the method returns Material.STONE
* @return the type of the first item, or STONE if the list is empty
*/
public Material getLogo() {
if (items.isEmpty()) {
return Material.STONE;
}
return items.get(0).getType();
}
/**
* Set the helmet slot for the class.
* @param helmet an item
*/
public void setHelmet(ItemStack helmet) {
this.helmet = helmet;
}
/**
* Set the chestplate slot for the class.
* @param chestplate an item
*/
public void setChestplate(ItemStack chestplate) {
this.chestplate = chestplate;
}
/**
* Set the leggings slot for the class.
* @param leggings an item
*/
public void setLeggings(ItemStack leggings) {
this.leggings = leggings;
}
/**
* Set the boots slot for the class.
* @param boots an item
*/
public void setBoots(ItemStack boots) {
this.boots = boots;
}
/**
* Add an item to the items list.
* If the item is a weapon-type, its durability will be set to "infinite".
* If the item is a bone, the pets counter will be incremented.
* @param stack an item
*/
public void addItem(ItemStack stack) {
if (stack == null) return;
if (isWeapon(stack)) {
stack.setDurability(Short.MIN_VALUE);
}
else if (stack.getType() == Material.BONE) {
pets += stack.getAmount();
}
items.add(stack);
}
/**
* Replace the current items list with a new list of all the items in the given list.
* This method uses the addItem() method for each item to ensure consistency.
* @param stacks a list of items
*/
public void setItems(List<ItemStack> stacks) {
this.items = new ArrayList<ItemStack>(stacks.size());
for (ItemStack stack : stacks) {
addItem(stack);
}
}
/**
* Replace the current armor list with the given list.
* @param armor a list of items
*/
public void setArmor(List<ItemStack> armor) {
this.armor = armor;
}
/**
* Grants all of the class items and armor to the given player.
* The normal items will be added to the inventory normally, while the
* armor items will be verified as armor items and placed in their
* appropriate slots. If any specific armor slots are specified, they
* will overwrite any items in the armor list.
* @param p a player
*/
public void grantItems(Player p) {
PlayerInventory inv = p.getInventory();
// Fork over the items.
for (ItemStack stack : items) {
inv.addItem(stack);
}
// Check for legacy armor-node items
if (!armor.isEmpty()) {
for (ItemStack piece : armor) {
ArmorType type = ArmorType.getType(piece);
if (type == null) continue;
switch (type) {
case HELMET:
inv.setHelmet(piece);
break;
case CHESTPLATE:
inv.setChestplate(piece);
break;
case LEGGINGS:
inv.setLeggings(piece);
break;
case BOOTS:
inv.setBoots(piece);
break;
default:
break;
}
}
}
// Check type specifics.
if (helmet != null) inv.setHelmet(helmet);
if (chestplate != null) inv.setChestplate(chestplate);
if (leggings != null) inv.setLeggings(leggings);
if (boots != null) inv.setBoots(boots);
}
/**
* Add a permission value to the class.
* @param perm the permission
* @param value the value
*/
public void addPermission(String perm, boolean value) {
perms.put(perm, value);
}
/**
* Get an unmodifiable map of permissions and values for the class.
* @return a map of permissions and values
*/
public Map<String,Boolean> getPermissions() {
return Collections.unmodifiableMap(perms);
}
/**
* Grant the given player all the permissions of the class.
* All permissions will be attached to a PermissionAttachment object, which
* will be returned to the caller.
* @param plugin a MobArena instance
* @param p a player
* @return the PermissionAttachment with all the permissions
*/
public PermissionAttachment grantPermissions(MobArena plugin, Player p) {
if (perms.isEmpty()) return null;
PermissionAttachment pa = p.addAttachment(plugin);
for (Entry<String,Boolean> entry : perms.entrySet()) {
try {
pa.setPermission(entry.getKey(), entry.getValue());
}
catch (Exception e) {
String perm = entry.getKey() + ":" + entry.getValue();
String player = p.getName();
plugin.warning("[PERM00] Failed to attach permission '" + perm + "' to player '" + player + " with class " + this.name
+ "'.\nPlease verify that your class permissions are well-formed.");
}
}
return pa;
}
/**
* Get the amount of pets this class is given upon starting the arena.
* @return the number of pets this class has
*/
public int getPetAmount() {
return pets;
}
/**
* Used by isWeapon() to determine if an ItemStack is a weapon type.
*/
private static int[] weaponTypes = new int[]{256,257,258,267,268,269,270,271,272,273,274,275,276,277,278,279,283,284,285,286,290,291,292,293,294};
/**
* Returns true, if the ItemStack appears to be a weapon, in which case
* the addItem() method will set the weapon durability to the absolute
* maximum, as to give them "infinite" durability.
* @param stack an ItemStack
* @return true, if the item is a weapon
*/
private boolean isWeapon(ItemStack stack) {
int id = stack.getTypeId();
for (int type : weaponTypes) {
if (id == type) {
return true;
}
}
return false;
}
/**
* Used by the grantItems() method to determine the armor type of a given
* ItemStack. Armor pieces are auto-equipped.
* Note: This enum is only necessary for backward-compatibility with the
* 'armor'-node.
*/
public enum ArmorType {
HELMET (298,302,306,310,314),
CHESTPLATE (299,303,307,311,315),
LEGGINGS (300,304,308,312,316),
BOOTS (301,305,309,313,317);
private int[] types;
private ArmorType(int... types) {
this.types = types;
}
public static ArmorType getType(ItemStack stack) {
int id = stack.getTypeId();
for (ArmorType armorType : ArmorType.values()) {
for (int type : armorType.types) {
if (id == type) {
return armorType;
}
}
}
return null;
}
}
}

1270
src/com/garbagemule/MobArena/ArenaImpl.java Normal file
View File

File diff suppressed because it is too large Load Diff

789
src/com/garbagemule/MobArena/ArenaListenerImpl.java Normal file
View File

@ -0,0 +1,789 @@
package com.garbagemule.MobArena;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Set;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.ContainerBlock;
import org.bukkit.block.Sign;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.Slime;
import org.bukkit.entity.Wolf;
import org.bukkit.event.Event.Result;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockEvent;
import org.bukkit.event.block.BlockFormEvent;
import org.bukkit.event.block.BlockIgniteEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.block.SignChangeEvent;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.entity.EntityRegainHealthEvent;
import org.bukkit.event.entity.EntityTargetEvent;
import org.bukkit.event.entity.FoodLevelChangeEvent;
import org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason;
import org.bukkit.event.entity.EntityTargetEvent.TargetReason;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerAnimationEvent;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.material.Attachable;
import org.bukkit.material.Bed;
import org.bukkit.material.Door;
import org.bukkit.material.Redstone;
import com.garbagemule.MobArena.MAUtils;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.Msg;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaListener;
import com.garbagemule.MobArena.leaderboards.Leaderboard;
import com.garbagemule.MobArena.region.ArenaRegion;
import com.garbagemule.MobArena.region.RegionPoint;
import com.garbagemule.MobArena.repairable.*;
import com.garbagemule.MobArena.util.TextUtils;
import com.garbagemule.MobArena.util.config.ConfigSection;
import com.garbagemule.MobArena.waves.MABoss;
public class ArenaListenerImpl implements ArenaListener
{
private MobArena plugin;
private Arena arena;
private ArenaRegion region;
private MonsterManager monsters;
private boolean softRestore,
softRestoreDrops,
protect;
private boolean monsterExp,
monsterInfight,
pvpEnabled,
foodRegen,
lockFoodLevel;
private boolean allowTeleport,
canShare,
allowMonsters;
private Set<Player> banned;
public ArenaListenerImpl(Arena arena, MobArena plugin) {
this.plugin = plugin;
this.arena = arena;
this.region = arena.getRegion();
this.monsters = arena.getMonsterManager();
/*
* TODO: Figure out if this is really a good idea + It saves needing all
* those methods in Arena.java + It is relatively simple + It would be
* fairly easy to implement an observer pattern - More private fields -
* Uglier code
*/
ConfigSection s = arena.getSettings();
this.softRestore = s.getBoolean("soft-restore", false);
this.softRestoreDrops = s.getBoolean("soft-restore-drops", false);
this.protect = s.getBoolean("protect", true);
this.monsterExp = s.getBoolean("monster-exp", false);
this.monsterInfight = s.getBoolean("monster-infight", false);
this.pvpEnabled = s.getBoolean("pvp-enabled", false);
this.foodRegen = s.getBoolean("food-regen", false);
this.lockFoodLevel = s.getBoolean("lock-food-level", true);
this.allowTeleport = s.getBoolean("allow-teleporting", false);
this.canShare = s.getBoolean("share-items-in-arena", true);
this.allowMonsters = arena.getWorld().getAllowMonsters();
this.banned = new HashSet<Player>();
}
public void onBlockBreak(BlockBreakEvent event) {
if (onBlockDestroy(event))
return;
event.setCancelled(true);
}
public void onBlockBurn(BlockBurnEvent event) {
if (onBlockDestroy(event))
return;
event.setCancelled(true);
}
private boolean onBlockDestroy(BlockEvent event) {
if (!arena.getRegion().contains(event.getBlock().getLocation()) || arena.inEditMode() || (!arena.isProtected() && arena.isRunning()))
return true;
Block b = event.getBlock();
if (arena.removeBlock(b) || b.getType() == Material.TNT)
return true;
if (softRestore && arena.isRunning()) {
BlockState state = b.getState();
Repairable r = null;
if (state instanceof ContainerBlock)
r = new RepairableContainer(state);
else if (state instanceof Sign)
r = new RepairableSign(state);
else if (state.getData() instanceof Attachable)
r = new RepairableAttachable(state);
else
r = new RepairableBlock(state);
arena.addRepairable(r);
if (!softRestoreDrops)
b.setTypeId(0);
return true;
}
return false;
}
public void onBlockPlace(BlockPlaceEvent event) {
Block b = event.getBlock();
// If the event didn't happen in the region, or if in edit mode, ignore
if (!arena.getRegion().contains(b.getLocation()) || arena.inEditMode()) {
return;
}
// If the arena isn't running, or if the player isn't in the arena,
// cancel.
if (!arena.isRunning() || !arena.inArena(event.getPlayer())) {
event.setCancelled(true);
return;
}
// Otherwise, block was placed during a session.
arena.addBlock(b);
switch (b.getType()){
// For doors, add the block just above (so we get both halves)
case WOODEN_DOOR:
case IRON_DOOR_BLOCK:
arena.addBlock(b.getRelative(0, 1, 0));
break;
}
}
public void onBlockForm(BlockFormEvent event) {
if (!arena.getRegion().contains(event.getBlock().getLocation()))
return;
// If a snowman forms some snow on its path, add the block
if (event.getNewState().getType() == Material.SNOW)
arena.addBlock(event.getBlock());
}
public void onBlockIgnite(BlockIgniteEvent event) {
if (!arena.getRegion().contains(event.getBlock().getLocation()))
return;
switch (event.getCause()){
case LIGHTNING:
case SPREAD:
event.setCancelled(true);
break;
case FLINT_AND_STEEL:
if (arena.isRunning())
arena.addBlock(event.getBlock().getRelative(BlockFace.UP));
else
event.setCancelled(true);
break;
default:
break;
}
}
public void onSignChange(SignChangeEvent event) {
arena.setLeaderboard(new Leaderboard(plugin, arena, event.getBlock().getLocation()));
arena.getRegion().set(RegionPoint.LEADERBOARD, event.getBlock().getLocation());
Messenger.tellPlayer(event.getPlayer(), "Leaderboard made. Now set up the stat signs!");
}
public void onCreatureSpawn(CreatureSpawnEvent event) {
if (!arena.getRegion().contains(event.getLocation())) {
if (!event.isCancelled()) {
event.setCancelled(!allowMonsters);
}
return;
}
if (event.getSpawnReason() != SpawnReason.CUSTOM) {
event.setCancelled(true);
return;
}
LivingEntity entity = (LivingEntity) event.getEntity();
if (arena.isRunning() && entity instanceof Slime)
monsters.addMonster(entity);
// If running == true, setCancelled(false), and vice versa.
event.setCancelled(!arena.isRunning());
}
public void onEntityExplode(EntityExplodeEvent event) {
if (!monsters.getMonsters().contains(event.getEntity()) && !arena.getRegion().contains(event.getLocation(), 10))
return;
monsters.removeMonster(event.getEntity());
// Cancel if the arena isn't running
if (!arena.isRunning()) {
event.setCancelled(true);
return;
}
// Uncancel, just in case.
event.setCancelled(false);
// If the arena isn't destructible, just clear the blocklist.
if (!softRestore && protect) {
List<Block> blocks = new LinkedList<Block>(arena.getBlocks());
event.blockList().retainAll(blocks);
return;
}
if (!softRestoreDrops)
event.setYield(0);
// Handle all the blocks in the block list.
for (Block b : event.blockList()) {
BlockState state = b.getState();
if (state.getData() instanceof Door && ((Door) state.getData()).isTopHalf()) {
state = b.getRelative(BlockFace.DOWN).getState();
}
else if (state.getData() instanceof Bed && ((Bed) state.getData()).isHeadOfBed()) {
state = b.getRelative(((Bed) state.getData()).getFacing().getOppositeFace()).getState();
}
// Create a Repairable from the block.
Repairable r = null;
if (state instanceof ContainerBlock)
r = new RepairableContainer(state);
else if (state instanceof Sign)
r = new RepairableSign(state);
else if (state.getData() instanceof Bed)
r = new RepairableBed(state);
else if (state.getData() instanceof Door)
r = new RepairableDoor(state);
else if (state.getData() instanceof Attachable || state.getData() instanceof Redstone)
r = new RepairableAttachable(state);
else
r = new RepairableBlock(state);
// Cakes and liquids should just get removed. If player-placed block, drop as item.
Material mat = state.getType();
if (mat == Material.CAKE_BLOCK || mat == Material.WATER || mat == Material.LAVA)
arena.removeBlock(b);
else if (arena.removeBlock(b))
arena.getWorld().dropItemNaturally(b.getLocation(), new ItemStack(state.getTypeId(), 1));
else if (softRestore)
arena.addRepairable(r);
else
arena.queueRepairable(r);
}
}
/******************************************************
*
* DEATH LISTENERS
*
******************************************************/
public void onEntityDeath(EntityDeathEvent event) {
if (event instanceof PlayerDeathEvent) {
onPlayerDeath((PlayerDeathEvent) event, (Player) event.getEntity());
}
else if (monsters.removeMonster(event.getEntity())) {
onMonsterDeath(event);
}
}
private void onPlayerDeath(PlayerDeathEvent event, Player player) {
if (arena.inArena(player) || arena.inLobby(player)) {
event.getDrops().clear();
event.setDroppedExp(0);
event.setKeepLevel(true);
arena.playerDeath(player);
}
}
public boolean onPlayerRespawn(PlayerRespawnEvent event) {
Player p = event.getPlayer();
if (!arena.isDead(p)) {
return false;
}
Location loc = arena.getRespawnLocation(p);
event.setRespawnLocation(loc);
arena.playerRespawn(p);
return true;
}
private void onMonsterDeath(EntityDeathEvent event) {
EntityDamageEvent e1 = event.getEntity().getLastDamageCause();
EntityDamageByEntityEvent e2 = (e1 instanceof EntityDamageByEntityEvent) ? (EntityDamageByEntityEvent) e1 : null;
Entity damager = (e2 != null) ? e2.getDamager() : null;
// Make sure to grab the owner of a projectile/pet
if (damager instanceof Projectile) {
damager = ((Projectile) damager).getShooter();
}
else if (damager instanceof Wolf && arena.hasPet(damager)) {
damager = (Player) ((Wolf) damager).getOwner();
}
// If the damager was a player, add to kills.
if (damager instanceof Player) {
ArenaPlayer ap = arena.getArenaPlayer((Player) damager);
if (ap != null) {
ArenaPlayerStatistics stats = ap.getStats();
if (stats != null) {
ap.getStats().inc("kills");
}
}
}
if (!monsterExp)
event.setDroppedExp(0);
event.getDrops().clear();
List<ItemStack> loot = monsters.getLoot(event.getEntity());
if (loot != null && !loot.isEmpty()) {
event.getDrops().add(getRandomItem(loot));
}
return;
}
private ItemStack getRandomItem(List<ItemStack> stacks) {
return stacks.get((new Random()).nextInt(stacks.size()));
}
/******************************************************
*
* DAMAGE LISTENERS
*
******************************************************/
public void onEntityDamage(EntityDamageEvent event) {
Entity damagee = event.getEntity();
if (!arena.isRunning() || !arena.getRegion().contains(damagee.getLocation())) {
return;
}
EntityDamageByEntityEvent edbe = (event instanceof EntityDamageByEntityEvent) ? (EntityDamageByEntityEvent) event : null;
Entity damager = null;
if (edbe != null) {
damager = edbe.getDamager();
if (damager instanceof Projectile) {
damager = ((Projectile) damager).getShooter();
}
else if (damager instanceof Wolf && arena.hasPet(damager)) {
damager = (Player) ((Wolf) damager).getOwner();
}
}
// Pet wolf
if (damagee instanceof Wolf && arena.hasPet(damagee)) {
onPetDamage(event, (Wolf) damagee, damager);
}
// Player
else if (damagee instanceof Player) {
onPlayerDamage(event, (Player) damagee, damager);
}
// Boss
else if (monsters.getBossMonsters().contains(damagee)) {
onBossDamage(event, (LivingEntity) damagee, damager);
}
// Regular monster
else if (monsters.getMonsters().contains(damagee)) {
onMonsterDamage(event, damagee, damager);
}
}
private void onPlayerDamage(EntityDamageEvent event, Player player, Entity damager) {
// Cancel all damage in the lobby and spec area
if (arena.inLobby(player) || arena.inSpec(player)) {
event.setCancelled(true);
return;
}
// If PvP is disabled and damager is a player, cancel damage
else if (arena.inArena(player)) {
if (!pvpEnabled && damager instanceof Player) {
event.setCancelled(true);
return;
}
event.setCancelled(false);
arena.getArenaPlayer(player).getStats().add("dmgTaken", event.getDamage());
}
}
private void onPetDamage(EntityDamageEvent event, Wolf pet, Entity damager) {
event.setCancelled(true);
}
private void onMonsterDamage(EntityDamageEvent event, Entity monster, Entity damager) {
if (damager instanceof Player) {
Player p = (Player) damager;
if (!arena.inArena(p)) {
event.setCancelled(true);
return;
}
ArenaPlayerStatistics aps = arena.getArenaPlayer(p).getStats();
aps.add("dmgDone", event.getDamage());
aps.inc("hits");
}
else if (damager instanceof Wolf && arena.hasPet(damager)) {
event.setDamage(1);
Player p = (Player) ((Wolf) damager).getOwner();
ArenaPlayerStatistics aps = arena.getArenaPlayer(p).getStats();
aps.add("dmgDone", event.getDamage());
// arena.getArenaPlayer(p).getStats().dmgDone += event.getDamage();
}
else if (damager instanceof LivingEntity) {
if (!monsterInfight)
event.setCancelled(true);
}
}
private void onBossDamage(EntityDamageEvent event, LivingEntity monster, Entity damager) {
// Health the boss back up.
monster.setHealth(monster.getMaxHealth());
// Damage the underlying MABoss.
MABoss boss = monsters.getBoss(monster);
boss.damage(event.getDamage());
// If it died, remove it from the arena.
if (boss.isDead()) {
monsters.removeBoss(monster);
monster.damage(10000);
}
// And "cancel out" the damage.
event.setDamage(1);
}
public void onEntityCombust(EntityCombustEvent event) {
if (monsters.getMonsters().contains(event.getEntity()))
event.setCancelled(true);
}
public void onEntityTarget(EntityTargetEvent event) {
if (!arena.isRunning() || event.isCancelled())
return;
if (arena.hasPet(event.getEntity())) {
if (event.getReason() != TargetReason.TARGET_ATTACKED_OWNER && event.getReason() != TargetReason.OWNER_ATTACKED_TARGET)
return;
if (!(event.getTarget() instanceof Player))
return;
// If the target is a player, cancel.
event.setCancelled(true);
}
else if (monsters.getMonsters().contains(event.getEntity())) {
if (event.getReason() == TargetReason.FORGOT_TARGET)
event.setTarget(MAUtils.getClosestPlayer(plugin, event.getEntity(), arena));
else if (event.getReason() == TargetReason.TARGET_DIED)
event.setTarget(MAUtils.getClosestPlayer(plugin, event.getEntity(), arena));
else if (event.getReason() == TargetReason.TARGET_ATTACKED_ENTITY)
if (arena.hasPet(event.getTarget()))
event.setCancelled(true);
else if (event.getReason() == TargetReason.CLOSEST_PLAYER)
if (!arena.inArena((Player) event.getTarget()))
event.setCancelled(true);
}
}
public void onEntityChangeBlock(EntityChangeBlockEvent event) {
if (arena.getRegion().contains(event.getBlock().getLocation()))
event.setCancelled(true);
}
public void onEntityRegainHealth(EntityRegainHealthEvent event) {
if (!arena.isRunning())
return;
if (!(event.getEntity() instanceof Player) || !arena.inArena((Player) event.getEntity()))
return;
if (!foodRegen && event.getRegainReason() == RegainReason.SATIATED) {
event.setCancelled(true);
}
}
public void onFoodLevelChange(FoodLevelChangeEvent event) {
if (!arena.isRunning())
return;
if (!(event.getEntity() instanceof Player) || !arena.inArena((Player) event.getEntity()))
return;
// If the food level is locked, cancel all changes.
if (lockFoodLevel)
event.setCancelled(true);
}
public void onPlayerAnimation(PlayerAnimationEvent event) {
if (!arena.isRunning() || !arena.inArena(event.getPlayer()))
return;
arena.getArenaPlayer(event.getPlayer()).getStats().inc("swings");
}
public void onPlayerDropItem(PlayerDropItemEvent event) {
Player p = event.getPlayer();
// If the player is active in the arena, only cancel if sharing is not
// allowed
if (arena.inArena(p)) {
if (!canShare) {
Messenger.tellPlayer(p, Msg.LOBBY_DROP_ITEM);
event.setCancelled(true);
}
}
// Else, if the player is in the lobby or a spectator, just cancel
else if (arena.inLobby(p) || arena.inSpec(p)) {
Messenger.tellPlayer(p, Msg.LOBBY_DROP_ITEM);
event.setCancelled(true);
}
/*
* If the player is not in the arena in any way (as arena player, lobby
* player or a spectator), but they -are- in the region, it must mean
* they are trying to drop items when not allowed
*/
else if (region.contains(p.getLocation())) {
Messenger.tellPlayer(p, Msg.LOBBY_DROP_ITEM);
event.setCancelled(true);
}
/*
* If the player is in the banned set, it means they got kicked or
* disconnected during a session, meaning they are more than likely
* trying to steal items, if a PlayerDropItemEvent is fired.
*/
else if (banned.contains(p)) {
plugin.warning("Player " + p.getName() + " tried to steal class items!");
event.setCancelled(true);
}
}
public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
if (!arena.getReadyPlayersInLobby().contains(event.getPlayer()) && !arena.inArena(event.getPlayer()))
return;
if (!arena.isRunning()) {
event.getBlockClicked().getRelative(event.getBlockFace()).setTypeId(0);
event.setCancelled(true);
return;
}
Block liquid = event.getBlockClicked().getRelative(event.getBlockFace());
arena.addBlock(liquid);
}
public void onPlayerInteract(PlayerInteractEvent event) {
Player p = event.getPlayer();
if (arena.inArena(p) || !arena.inLobby(p))
return;
// Player is in the lobby, so disallow using items.
Action a = event.getAction();
if (a == Action.RIGHT_CLICK_AIR || a == Action.RIGHT_CLICK_BLOCK) {
event.setUseItemInHand(Result.DENY);
event.setCancelled(true);
}
// If there's no block involved, just return.
if (!event.hasBlock())
return;
// Iron block
if (event.getClickedBlock().getTypeId() == 42) {
handleReadyBlock(p);
}
// Sign
else if (event.getClickedBlock().getState() instanceof Sign) {
Sign sign = (Sign) event.getClickedBlock().getState();
handleSign(sign, p);
}
}
private void handleReadyBlock(Player p) {
if (arena.getArenaPlayer(p).getArenaClass() != null) {
Messenger.tellPlayer(p, Msg.LOBBY_PLAYER_READY);
arena.playerReady(p);
}
else {
Messenger.tellPlayer(p, Msg.LOBBY_PICK_CLASS);
}
}
private void handleSign(Sign sign, Player p) {
// Check if the first line is a class name.
String className = ChatColor.stripColor(sign.getLine(0)).toLowerCase();
if (!arena.getClasses().containsKey(className) && !className.equals("random"))
return;
// Check for permission.
if (!plugin.has(p, "mobarena.classes." + className) && !className.equals("random")) {
Messenger.tellPlayer(p, Msg.LOBBY_CLASS_PERMISSION);
return;
}
// Delay the inventory stuff to ensure that right-clicking works.
delayAssignClass(p, className);
}
private void delayAssignClass(final Player p, final String className) {
plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin,new Runnable() {
public void run() {
arena.assignClass(p, className);
if (!className.equalsIgnoreCase("random"))
Messenger.tellPlayer(p, Msg.LOBBY_CLASS_PICKED, TextUtils.camelCase(className), arena.getClassLogo(className));
else
Messenger.tellPlayer(p, Msg.LOBBY_CLASS_RANDOM);
}
});
}
public void onPlayerQuit(PlayerQuitEvent event) {
Player p = event.getPlayer();
if (!arena.isEnabled() || (!arena.inArena(p) && !arena.inLobby(p)))
return;
arena.playerLeave(p);
banned.add(p);
scheduleUnban(p, 20);
}
public void onPlayerKick(PlayerKickEvent event) {
Player p = event.getPlayer();
if (!arena.isEnabled() || (!arena.inArena(p) && !arena.inLobby(p))) {
return;
}
arena.playerLeave(p);
banned.add(p);
scheduleUnban(p, 20);
}
private void scheduleUnban(final Player p, int ticks) {
plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
public void run() {
banned.remove(p);
}
}, ticks);
}
public TeleportResponse onPlayerTeleport(PlayerTeleportEvent event) {
if (!arena.isEnabled() || !region.isSetup() || arena.inEditMode() || allowTeleport) {
return TeleportResponse.IDGAF;
}
Location to = event.getTo();
Location from = event.getFrom();
Player p = event.getPlayer();
if (region.contains(from)) {
// Players not in the arena are free to warp out.
if (!arena.inArena(p) && !arena.inLobby(p) && !arena.inSpec(p)) {
return TeleportResponse.ALLOW;
}
// Covers the case in which both locations are in the arena.
if (region.contains(to) || region.isWarp(to) || to.equals(arena.getPlayerEntry(p))) {
return TeleportResponse.ALLOW;
}
Messenger.tellPlayer(p, Msg.WARP_FROM_ARENA);
return TeleportResponse.REJECT;
}
else if (region.contains(to)) {
if (region.isWarp(from) || region.isWarp(to) || to.equals(arena.getPlayerEntry(p))) {
return TeleportResponse.ALLOW;
}
Messenger.tellPlayer(p, Msg.WARP_TO_ARENA);
return TeleportResponse.REJECT;
}
return TeleportResponse.IDGAF;
}
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
Player p = event.getPlayer();
if (event.isCancelled() || (!arena.inArena(p) && !arena.inLobby(p))) {
return;
}
// This is safe, because commands will always have at least one element.
String base = event.getMessage().split(" ")[0];
// Check if the entire base command is allowed.
if (plugin.getArenaMaster().isAllowed(base)) {
return;
}
// If not, check if the specific command is allowed.
String noslash = event.getMessage().substring(1);
if (plugin.getArenaMaster().isAllowed(noslash)) {
return;
}
// This is dirty, but it ensures that commands are indeed blocked.
event.setMessage("/");
// Cancel the event regardless.
event.setCancelled(true);
Messenger.tellPlayer(p, Msg.MISC_COMMAND_NOT_ALLOWED);
}
}

141
src/com/garbagemule/MobArena/ArenaLog.java
View File

@ -1,141 +0,0 @@
package com.garbagemule.MobArena;
import java.sql.Timestamp;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.util.data.PlainText;
import com.garbagemule.MobArena.util.data.Totals;
import com.garbagemule.MobArena.util.data.XML;
import com.garbagemule.MobArena.util.data.YAML;
public class ArenaLog
{
public MobArena plugin;
public Arena arena;
public Timestamp startTime, endTime;
public int lastWave;
public Map<Player,ArenaPlayer> players;
public Map<String,Integer> distribution;
/**
* Create a new ArenaLog.
* @param plugin MobArena instance
* @param arena The arena
*/
public ArenaLog(MobArena plugin, Arena arena)
{
this.plugin = plugin;
this.arena = arena;
this.players = new HashMap<Player,ArenaPlayer>(arena.arenaPlayers.size());
this.distribution = new HashMap<String,Integer>(arena.classes.size());
}
/**
* Start logging by creating ArenaPlayer objects and recording
* the class distributions and the start time.
*/
public void start()
{
// Populate the data maps
populatePlayerMap();
populateDistributionMap();
// Grab the current timestamp
startTime = new Timestamp((new Date()).getTime());
}
/**
* End logging by recording the last wave and the end time.
*/
public void end()
{
lastWave = arena.spawnThread.getWave() - 1;
endTime = new Timestamp((new Date()).getTime());
}
/**
* Map players to ArenaPlayer objects.
*/
private void populatePlayerMap()
{
for (Player p : arena.arenaPlayers)
players.put(p, new ArenaPlayer(p, arena, plugin));
}
/**
* Map classes to amounts of players playing as the classes.
*/
private void populateDistributionMap()
{
// Initialize the map
for (String c : arena.classes)
distribution.put(c,0);
// Count occurrences
for (String c : arena.classMap.values())
distribution.put(c,distribution.get(c) + 1);
}
/**
* Save the data of the current session according to the logging type.
*/
public void saveSessionData()
{
if (arena.logging.equals("xml"))
XML.saveSessionData(this);
else if (arena.logging.equals("yml") || arena.logging.equals("yaml"))
YAML.saveSessionData(this);
else
PlainText.saveSessionData(this);
//CSV.saveSessionData(this, plugin);
//YAML.saveSessionData(this);
}
/**
* Update the totals-file
*/
public void updateArenaTotals()
{
Totals.updateArenaTotals(this);
if (arena.logging.equals("xml"))
XML.updateArenaTotals(this);
//PlainText.updateArenaTotals(this);
}
/**
* Clear maps.
*/
public void clearSessionData()
{
players.clear();
distribution.clear();
}
public Arena getArena() { return arena; }
public Timestamp getStartTime() { return startTime; }
public Timestamp getEndTime() { return endTime; }
public String getDuration() { return MAUtils.getDuration(endTime.getTime() - startTime.getTime()); }
public long getDurationLong() { return endTime.getTime() - startTime.getTime(); }
public int getLastWave() { return lastWave; }
public void playerKill(Player p)
{
players.get(p).getStats().kills++;
}
public void playerDamager(Player p, int damage)
{
players.get(p).getStats().dmgDone += damage;
}
public void playerDamagee(Player p, int damage)
{
players.get(p).getStats().dmgTaken += damage;
}
}

147
src/com/garbagemule/MobArena/ArenaMaster.java
View File

@ -1,147 +0,0 @@
package com.garbagemule.MobArena;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
//import org.bukkit.util.config.Configuration;
//import com.garbagemule.ArenaPlugin.Master;
public abstract class ArenaMaster //implements Master
{
protected Arena selectedArena;
// Settings
protected boolean enabled, updateNotify;
// Classes
protected Set<String> classes;
protected Map<String,List<ItemStack>> classItems, classArmor;
protected Map<String,Map<String,Boolean>> classPerms;
//protected Map<Integer,Map<Player,List<ItemStack>>> classBonuses;
protected Map<Player,Arena> arenaMap;
// Location map
protected Map<Player,Location> locations = new HashMap<Player,Location>();
// Arena list
protected List<Arena> arenas;
// Listeners
protected Set<MobArenaListener> listeners = new HashSet<MobArenaListener>();
/*/////////////////////////////////////////////////////////////////////////
//
// Arena getters
//
/////////////////////////////////////////////////////////////////////////*/
public abstract List<Arena> getEnabledArenas();
public abstract List<Arena> getPermittedArenas(Player p);
public abstract List<Arena> getEnabledAndPermittedArenas(Player p);
public abstract Arena getArenaAtLocation(Location loc);
public abstract List<Arena> getArenasInWorld(World world);
public abstract List<Player> getAllPlayers();
public abstract List<Player> getAllPlayersInArena(String arenaName);
public abstract List<Player> getAllLivingPlayers();
public abstract List<Player> getLivingPlayersInArena(String arenaName);
public abstract Arena getArenaWithPlayer(Player p);
public abstract Arena getArenaWithPlayer(String playerName);
public abstract Arena getArenaWithSpectator(Player p);
public abstract Arena getArenaWithMonster(Entity e);
public abstract Arena getArenaWithPet(Entity e);
public abstract Arena getArenaWithName(String configName);
public abstract Arena getArenaWithName(Collection<Arena> arenas, String configName);
/*/////////////////////////////////////////////////////////////////////////
//
// Initialization
//
/////////////////////////////////////////////////////////////////////////*/
public abstract void initialize();
/**
* Load the global settings.
*/
public abstract void loadSettings();
/**
* Load all class-related stuff.
*/
public abstract void loadClasses();
/**
* Load all arena-related stuff.
*/
public abstract void loadArenas();
public abstract Arena createArenaNode(String configName, World world);
public abstract void removeArenaNode(String configName);
/*/////////////////////////////////////////////////////////////////////////
//
// Update and serialization methods
//
/////////////////////////////////////////////////////////////////////////*/
/**
* Update one, two or all three of global settings, classes
* and arenas (arenas with deserialization).
*/
public abstract void update(boolean settings, boolean classes, boolean arenalist);
/**
* Serialize the global settings.
*/
public abstract void serializeSettings();
/**
* Serialize all arena configs.
*/
public abstract void serializeArenas();
/**
* Deserialize all arena configs. Updates the arena list to
* include only the current arenas (not ones added in the
* actual file) that are also in the config-file.
*/
public abstract void deserializeArenas();
public abstract void updateSettings();
public abstract void updateClasses();
public abstract void updateArenas();
public abstract void updateAll();
}

591
src/com/garbagemule/MobArena/ArenaMasterImpl.java Normal file
View File

@ -0,0 +1,591 @@
package com.garbagemule.MobArena;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionDefault;
import org.bukkit.plugin.PluginManager;
import com.garbagemule.MobArena.ArenaImpl;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.ArenaClass.ArmorType;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.ItemParser;
import com.garbagemule.MobArena.util.TextUtils;
import com.garbagemule.MobArena.util.config.Config;
import com.garbagemule.MobArena.util.config.ConfigSection;
import com.garbagemule.MobArena.util.config.ConfigUtils;
public class ArenaMasterImpl implements ArenaMaster
{
private MobArena plugin;
private Config config;
private List<Arena> arenas;
private Map<Player, Arena> arenaMap;
private Arena selectedArena;
private Map<String, ArenaClass> classes;
private Set<String> allowedCommands;
/**
* Default constructor.
*/
public ArenaMasterImpl(MobArena plugin) {
this.plugin = plugin;
this.config = plugin.getMAConfig();
this.arenas = new LinkedList<Arena>();
this.arenaMap = new HashMap<Player, Arena>();
this.classes = new HashMap<String, ArenaClass>();
this.allowedCommands = new HashSet<String>();
}
/*
* /////////////////////////////////////////////////////////////////////////
* // // NEW METHODS IN REFACTORING //
* /////////////////////////////////////////////////////////////////////////
*/
public MobArena getPlugin() {
return plugin;
}
public boolean isEnabled() {
return config.getBoolean("global-settings.enabled", true);
}
public void setEnabled(boolean value) {
config.set("global-settings.enabled", value);
}
public boolean notifyOnUpdates() {
return config.getBoolean("global-settings.update-notification", false);
}
public Arena getSelectedArena() {
return selectedArena;
}
public void setSelectedArena(Arena arena) {
selectedArena = arena;
}
public List<Arena> getArenas() {
return arenas;
}
public Map<String, ArenaClass> getClasses() {
return classes;
}
public void addPlayer(Player p, Arena arena) {
arenaMap.put(p, arena);
}
public Arena removePlayer(Player p) {
return arenaMap.remove(p);
}
public void resetArenaMap() {
arenaMap.clear();
}
public boolean isAllowed(String command) {
return allowedCommands.contains(command);
}
/*
* /////////////////////////////////////////////////////////////////////////
* // // Arena getters //
* /////////////////////////////////////////////////////////////////////////
*/
public List<Arena> getEnabledArenas() {
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (arena.isEnabled())
result.add(arena);
return result;
}
public List<Arena> getPermittedArenas(Player p) {
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (plugin.has(p, "mobarena.arenas." + arena.configName()))
result.add(arena);
return result;
}
public List<Arena> getEnabledAndPermittedArenas(Player p) {
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (arena.isEnabled() && plugin.has(p, "mobarena.arenas." + arena.configName()))
result.add(arena);
return result;
}
public Arena getArenaAtLocation(Location loc) {
for (Arena arena : arenas)
if (arena.getRegion().contains(loc))
return arena;
return null;
}
public List<Arena> getArenasInWorld(World world) {
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (arena.getWorld().equals(world))
result.add(arena);
return result;
}
public List<Player> getAllPlayers() {
List<Player> result = new LinkedList<Player>();
for (Arena arena : arenas)
result.addAll(arena.getAllPlayers());
return result;
}
public List<Player> getAllPlayersInArena(String arenaName) {
Arena arena = getArenaWithName(arenaName);
return (arena != null) ? new LinkedList<Player>(arena.getPlayersInArena()) : new LinkedList<Player>();
}
public List<Player> getAllLivingPlayers() {
List<Player> result = new LinkedList<Player>();
for (Arena arena : arenas)
result.addAll(arena.getPlayersInArena());
return result;
}
public List<Player> getLivingPlayersInArena(String arenaName) {
Arena arena = getArenaWithName(arenaName);
return (arena != null) ? new LinkedList<Player>(arena.getPlayersInArena()) : new LinkedList<Player>();
}
public Arena getArenaWithPlayer(Player p) {
return arenaMap.get(p);
}
public Arena getArenaWithPlayer(String playerName) {
return arenaMap.get(plugin.getServer().getPlayer(playerName));
}
public Arena getArenaWithSpectator(Player p) {
for (Arena arena : arenas) {
if (arena.getSpectators().contains(p))
return arena;
}
return null;
}
public Arena getArenaWithMonster(Entity e) {
for (Arena arena : arenas)
if (arena.getMonsterManager().getMonsters().contains(e))
return arena;
return null;
}
public Arena getArenaWithPet(Entity e) {
for (Arena arena : arenas)
if (arena.hasPet(e))
return arena;
return null;
}
public Arena getArenaWithName(String configName) {
return getArenaWithName(this.arenas, configName);
}
public Arena getArenaWithName(Collection<Arena> arenas, String configName) {
for (Arena arena : arenas)
if (arena.configName().equals(configName))
return arena;
return null;
}
/*
* /////////////////////////////////////////////////////////////////////////
* // // Initialization //
* /////////////////////////////////////////////////////////////////////////
*/
public void initialize() {
config.load();
loadSettings();
loadClasses();
loadArenas();
config.save();
}
/**
* Load the global settings.
*/
public void loadSettings() {
ConfigUtils.replaceAllNodes(plugin, config, "global-settings", "global-settings.yml");
ConfigSection section = config.getConfigSection("global-settings");
// Grab the commands string
String cmds = section.getString("allowed-commands", "");
// Split by commas
String[] parts = cmds.split(",");
// Add in the /ma command.
allowedCommands.add("/ma");
// Add in each command
for (String part : parts) {
allowedCommands.add(part.trim().toLowerCase());
}
}
/**
* Load all class-related stuff.
*/
public void loadClasses() {
Set<String> classNames = config.getKeys("classes");
// If no classes were found, load the defaults.
if (classNames == null || classNames.isEmpty()) {
loadDefaultClasses();
classNames = config.getKeys("classes");
}
// Establish the map.
classes = new HashMap<String, ArenaClass>();
// Load each individual class.
for (String className : classNames) {
loadClass(className.toLowerCase());
}
}
/**
* Loads the classes in res/classes.yml into the config-file.
*/
public void loadDefaultClasses() {
ConfigUtils.addMissingNodes(plugin, config, "classes", "classes.yml");
}
/**
* Helper method for loading a single class.
*/
private ArenaClass loadClass(String className) {
// Grab the class section.
ConfigSection section = config.getConfigSection("classes." + TextUtils.camelCase(className));
// If the section doesn't exist, the class doesn't either.
if (section == null) {
plugin.error("Failed to load class '" + TextUtils.camelCase(className) + "'.");
return null;
}
ArenaClass arenaClass = new ArenaClass(className);
// Parse the items-node
String items = section.getString("items", "");
if (!items.equals("")) {
List<ItemStack> stacks = ItemParser.parseItems(items);
arenaClass.setItems(stacks);
}
// And the legacy armor-node
String armor = section.getString("armor", "");
if (!armor.equals("")) {
List<ItemStack> stacks = ItemParser.parseItems(armor);
arenaClass.setArmor(stacks);
}
// Get armor strings
String head = section.getString("helmet", null);
String chest = section.getString("chestplate", null);
String legs = section.getString("leggings", null);
String feet = section.getString("boots", null);
// Parse to ItemStacks
ItemStack helmet = ItemParser.parseItem(head);
ItemStack chestplate = ItemParser.parseItem(chest);
ItemStack leggings = ItemParser.parseItem(legs);
ItemStack boots = ItemParser.parseItem(feet);
// Set in ArenaClass
arenaClass.setHelmet(helmet);
arenaClass.setChestplate(chestplate);
arenaClass.setLeggings(leggings);
arenaClass.setBoots(boots);
// Per-class permissions
loadClassPermissions(arenaClass, section);
// Register the permission.
registerPermission("mobarena.classes." + className, PermissionDefault.TRUE).addParent("mobarena.classes", true);
// Finally add the class to the classes map.
classes.put(className, arenaClass);
return arenaClass;
}
private void loadClassPermissions(ArenaClass arenaClass, ConfigSection section) {
List<String> perms = section.getStringList("permissions", null);
if (perms.isEmpty())
return;
for (String perm : perms) {
// If the permission starts with - or ^, it must be revoked.
boolean value = true;
if (perm.startsWith("-") || perm.startsWith("^")) {
perm = perm.substring(1).trim();
value = false;
}
arenaClass.addPermission(perm, value);
}
}
public ArenaClass createClassNode(String className, PlayerInventory inv, boolean safe) {
String path = "classes." + TextUtils.camelCase(className);
if (safe && config.getConfigSection(path) != null) {
return null;
}
// Create the node.
config.set(path, "");
// Grab the section.
ConfigSection section = config.getConfigSection(path);
// Take the current items and armor.
section.set("items", ItemParser.parseString(inv.getContents()));
section.set("armor", ItemParser.parseString(inv.getArmorContents()));
// If the helmet isn't a real helmet, set it explicitly.
ItemStack helmet = inv.getHelmet();
if (helmet.getTypeId() != 0 && ArmorType.getType(helmet) != ArmorType.HELMET) {
section.set("helmet", ItemParser.parseString(helmet));
}
// Save changes.
config.save();
// Load the class
return loadClass(className.toLowerCase());
}
public void removeClassNode(String className) {
if (!classes.containsKey(className.toLowerCase()))
throw new IllegalArgumentException("Class does not exist!");
// Remove the class from the config-file and save it.
config.remove("classes." + className);
config.save();
// Remove the class from the map.
classes.remove(className.toLowerCase());
unregisterPermission("mobarena.arenas." + className.toLowerCase());
}
public boolean addClassPermission(String className, String perm) {
return addRemoveClassPermission(className, perm, true);
}
public boolean removeClassPermission(String className, String perm) {
return addRemoveClassPermission(className, perm, false);
}
private boolean addRemoveClassPermission(String className, String perm, boolean add) {
String path = "classes." + TextUtils.camelCase(className);
if (config.getConfigSection(path) == null)
return false;
// Grab the class section
ConfigSection section = config.getConfigSection(path);
// Get any previous nodes
List<String> nodes = section.getStringList("permissions", null);
if (nodes.contains(perm))
return false;
// Add or remove.
if (add) {
removeContradictions(nodes, perm);
nodes.add(perm);
}
else {
nodes.remove(perm);
}
// Replace the set.
section.set("permissions", nodes);
config.save();
// Reload the class.
loadClass(className);
return true;
}
/**
* Removes any nodes that would contradict the permission, e.g. if the node
* 'mobarena.use' is in the set, and the perm node is '-mobarena.use', the
* '-mobarena.use' node is removed as to not contradict the new
* 'mobarena.use' node.
*/
private void removeContradictions(List<String> nodes, String perm) {
if (perm.startsWith("^") || perm.startsWith("-")) {
nodes.remove(perm.substring(1).trim());
}
else {
nodes.remove("^" + perm);
nodes.remove("-" + perm);
}
}
/**
* Load all arena-related stuff.
*/
public void loadArenas() {
Set<String> arenaNames = config.getKeys("arenas");
// If no arenas were found, create a default node.
if (arenaNames == null || arenaNames.isEmpty()) {
createArenaNode("default", plugin.getServer().getWorlds().get(0));
arenaNames = config.getKeys("arenas");
}
// Establish the list.
arenas = new LinkedList<Arena>();
for (String arenaName : arenaNames) {
loadArena(arenaName);
}
selectedArena = arenas.get(0);
}
private Arena loadArena(String arenaName) {
String path = "arenas." + arenaName;
String worldName = config.getString(path + ".settings.world", "");
World world = null;
// If a string was found, try to fetch the world from the server.
if (!worldName.equals("")) {
world = plugin.getServer().getWorld(worldName);
if (world == null) {
plugin.error("The world '" + worldName + "' for arena '" + arenaName + "' does not exist!");
return null;
}
}
// Otherwise, use the default world.
else {
world = plugin.getServer().getWorlds().get(0);
plugin.warning("Could not find the world for arena '" + arenaName + "'. Using default world ('" + world.getName() + "')! Check the config-file!");
}
// Assert all settings nodes.
ConfigUtils.replaceAllNodes(plugin, config, path + ".settings", "settings.yml");
// Create an Arena with the name and world.
Arena arena = new ArenaImpl(plugin, config, arenaName, world);
// Register the permission
registerPermission("mobarena.arenas." + arenaName, PermissionDefault.TRUE);
// Finally, add it to the arena list.
arenas.add(arena);
return arena;
}
public Arena createArenaNode(String arenaName, World world) {
String path = "arenas." + arenaName;
if (config.getConfigSection(path) != null)
throw new IllegalArgumentException("Arena already exists!");
// Extract the default settings and update the world-node.
ConfigUtils.replaceAllNodes(plugin, config, path + ".settings", "settings.yml");
config.set(path + ".settings.world", world.getName());
// Extract the default waves.
ConfigUtils.replaceAllNodes(plugin, config, path + ".waves", "waves.yml");
// Extract the default rewards.
ConfigUtils.replaceAllNodes(plugin, config, path + ".rewards", "rewards.yml");
// Save the changes.
config.save();
// Load the arena
return loadArena(arenaName);
}
public void removeArenaNode(Arena arena) {
// Remove the arena from the config-file and save it.
config.remove("arenas." + arena.configName());
config.save();
// Remove the arena from the list.
arenas.remove(arena);
unregisterPermission("mobarena.arenas." + arena.configName());
}
public void reloadConfig() {
boolean wasEnabled = isEnabled();
// If MobArena was enabled, disable it before updating.
if (wasEnabled) {
setEnabled(false);
}
for (Arena a : arenas) {
a.forceEnd();
}
config.load();
loadSettings();
loadClasses();
loadArenas();
// If MobArena was enabled, re-enable it after updating.
if (wasEnabled) {
setEnabled(true);
}
}
public void saveConfig() {
config.save();
}
private Permission registerPermission(String permString, PermissionDefault value) {
PluginManager pm = plugin.getServer().getPluginManager();
Permission perm = pm.getPermission(permString);
if (perm == null) {
perm = new Permission(permString);
perm.setDefault(value);
pm.addPermission(perm);
}
return perm;
}
private void unregisterPermission(String s) {
plugin.getServer().getPluginManager().removePermission(s);
}
}

388
src/com/garbagemule/MobArena/ArenaMasterStandard.java
View File

@ -1,388 +0,0 @@
package com.garbagemule.MobArena;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.util.Config;
public class ArenaMasterStandard extends ArenaMaster
{
private MobArena plugin;
private Config config;
/**
* Default constructor.
*/
public ArenaMasterStandard(MobArenaPlugin instance)
{
plugin = (MobArena) instance;
config = plugin.getMAConfig();
arenas = new LinkedList<Arena>();
arenaMap = new HashMap<Player,Arena>();
}
/*/////////////////////////////////////////////////////////////////////////
//
// Arena getters
//
/////////////////////////////////////////////////////////////////////////*/
public List<Arena> getEnabledArenas()
{
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (arena.enabled)
result.add(arena);
return result;
}
public List<Arena> getPermittedArenas(Player p)
{
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (plugin.has(p, "mobarena.arenas." + arena.configName()))
result.add(arena);
return result;
}
public List<Arena> getEnabledAndPermittedArenas(Player p)
{
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (arena.enabled && plugin.has(p, "mobarena.arenas." + arena.configName()))
result.add(arena);
return result;
}
public Arena getArenaAtLocation(Location loc)
{
for (Arena arena : arenas)
if (arena.inRegion(loc))
return arena;
return null;
}
public List<Arena> getArenasInWorld(World world)
{
List<Arena> result = new LinkedList<Arena>();
for (Arena arena : arenas)
if (arena.world.equals(world))
result.add(arena);
return result;
}
public List<Player> getAllPlayers()
{
List<Player> result = new LinkedList<Player>();
for (Arena arena : arenas)
result.addAll(arena.getAllPlayers());
return result;
}
public List<Player> getAllPlayersInArena(String arenaName)
{
Arena arena = getArenaWithName(arenaName);
return (arena != null) ? arena.getLivingPlayers() : new LinkedList<Player>();
}
public List<Player> getAllLivingPlayers()
{
List<Player> result = new LinkedList<Player>();
for (Arena arena : arenas)
result.addAll(arena.getLivingPlayers());
return result;
}
public List<Player> getLivingPlayersInArena(String arenaName)
{
Arena arena = getArenaWithName(arenaName);
return (arena != null) ? arena.getLivingPlayers() : new LinkedList<Player>();
}
public Arena getArenaWithPlayer(Player p)
{
return arenaMap.get(p);
}
public Arena getArenaWithPlayer(String playerName)
{
return arenaMap.get(Bukkit.getServer().getPlayer(playerName));
}
public Arena getArenaWithSpectator(Player p)
{
for (Arena arena : arenas)
{
if (arena.specPlayers.contains(p))
return arena;
}
return null;
}
public Arena getArenaWithMonster(Entity e)
{
for (Arena arena : arenas)
if (arena.monsters.contains(e))
return arena;
return null;
}
public Arena getArenaWithPet(Entity e)
{
for (Arena arena : arenas)
if (arena.pets.contains(e))
return arena;
return null;
}
public Arena getArenaWithName(String configName)
{
return getArenaWithName(this.arenas, configName);
}
public Arena getArenaWithName(Collection<Arena> arenas, String configName)
{
for (Arena arena : arenas)
if (arena.configName().equals(configName))
return arena;
return null;
}
/*/////////////////////////////////////////////////////////////////////////
//
// Initialization
//
/////////////////////////////////////////////////////////////////////////*/
public void initialize()
{
config.load();
loadSettings();
loadClasses();
loadArenas();
config.save();
}
/**
* Load the global settings.
*/
public void loadSettings()
{
if (config.getKeys("global-settings") == null)
{
config.setProperty("global-settings.enabled", true);
config.setProperty("global-settings.update-notification", true);
}
enabled = config.getBoolean("global-settings.enabled", true);
updateNotify = config.getBoolean("global-settings.update-notification", true);
}
/**
* Load all class-related stuff.
*/
public void loadClasses()
{
classes = config.getKeys("classes");
if (classes == null)
{
config.setProperty("classes.Archer.items", "wood_sword, bow, arrow:128, grilled_pork");
config.setProperty("classes.Archer.armor", "298,299,300,301");
config.setProperty("classes.Knight.items", "diamond_sword, grilled_pork:2");
config.setProperty("classes.Knight.armor", "306,307,308,309");
config.setProperty("classes.Tank.items", "iron_sword, grilled_pork:3, apple");
config.setProperty("classes.Tank.armor", "310,311,312,313");
config.setProperty("classes.Oddjob.items", "stone_sword, flint_and_steel, netherrack:2, wood_pickaxe, tnt:4, fishing_rod, apple, grilled_pork:3");
config.setProperty("classes.Oddjob.armor", "298,299,300,301");
config.setProperty("classes.Chef.items", "stone_sword, bread:6, grilled_pork:4, mushroom_soup, cake:3, cookie:12");
config.setProperty("classes.Chef.armor", "314,315,316,317");
classes = config.getKeys("classes");
}
classItems = MAUtils.getClassItems(config, "items");
classArmor = MAUtils.getClassItems(config, "armor");
classPerms = MAUtils.getClassPerms(config);
}
/**
* Load all arena-related stuff.
*/
public void loadArenas()
{
arenas = new LinkedList<Arena>();
if (config.getKeys("arenas") == null)
createArenaNode("default", Bukkit.getServer().getWorlds().get(0));
for (String configName : config.getKeys("arenas"))
{
String arenaPath = "arenas." + configName + ".";
String worldName = config.getString(arenaPath + "settings.world", null);
World world;
if (worldName == null || worldName.equals(""))
{
MobArena.warning("Could not find the world for arena '" + configName + "'. Using default world! Check the config-file!");
world = Bukkit.getServer().getWorlds().get(0);
}
else world = Bukkit.getServer().getWorld(worldName);
Arena arena = new ArenaStandard(MAUtils.nameConfigToArena(configName), world);
arena.load(config);
arenas.add(arena);
}
selectedArena = arenas.get(0);
}
public Arena createArenaNode(String configName, World world)
{
config.setProperty("arenas." + configName + ".settings.world", world.getName());
config.save();
config.load();
config.setProperty("arenas." + configName + ".settings.enabled", true);
config.save();
config.load();
config.setProperty("arenas." + configName + ".settings.protect", true);
config.save();
config.load();
config.setProperty("arenas." + configName + ".settings.entry-fee", "");
config.save();
config.load();
config.setProperty("arenas." + configName + ".settings.logging", false);
config.setProperty("arenas." + configName + ".settings.clear-wave-before-next", false);
config.setProperty("arenas." + configName + ".settings.detonate-creepers", false);
config.setProperty("arenas." + configName + ".settings.detonate-damage", false);
config.setProperty("arenas." + configName + ".settings.lightning", true);
config.setProperty("arenas." + configName + ".settings.auto-equip-armor", true);
config.setProperty("arenas." + configName + ".settings.force-restore", false);
config.setProperty("arenas." + configName + ".settings.soft-restore", false);
config.setProperty("arenas." + configName + ".settings.soft-restore-drops", false);
config.setProperty("arenas." + configName + ".settings.require-empty-inv-join", true);
config.setProperty("arenas." + configName + ".settings.require-empty-inv-spec", true);
config.setProperty("arenas." + configName + ".settings.hellhounds", false);
config.setProperty("arenas." + configName + ".settings.pvp-enabled", false);
config.setProperty("arenas." + configName + ".settings.monster-infight", false);
config.setProperty("arenas." + configName + ".settings.allow-teleporting", false);
config.setProperty("arenas." + configName + ".settings.spectate-on-death", true);
config.setProperty("arenas." + configName + ".settings.share-items-in-arena", true);
config.save();
config.load();
config.setProperty("arenas." + configName + ".settings.player-limit", 0);
config.setProperty("arenas." + configName + ".settings.max-join-distance", 0);
config.save();
config.load();
config.setProperty("arenas." + configName + ".settings.repair-delay", 5);
config.setProperty("arenas." + configName + ".settings.first-wave-delay", 5);
config.setProperty("arenas." + configName + ".settings.wave-interval", 20);
config.setProperty("arenas." + configName + ".settings.special-modulo", 4);
config.setProperty("arenas." + configName + ".settings.max-idle-time", 0);
config.save();
config.load();
Arena arena = new ArenaStandard(MAUtils.nameConfigToArena(configName), world);
arena.load(config);
return arena;
}
public void removeArenaNode(String configName)
{
config.removeProperty("arenas." + configName);
config.save();
}
/*/////////////////////////////////////////////////////////////////////////
//
// Update and serialization methods
//
/////////////////////////////////////////////////////////////////////////*/
/**
* Update one, two or all three of global settings, classes
* and arenas (arenas with deserialization).
*/
public void update(boolean settings, boolean classes, boolean arenalist)
{
boolean tmp = enabled;
enabled = false;
for (Arena arena : arenas)
arena.forceEnd();
config.load();
if (settings) loadSettings();
if (classes) loadClasses();
if (arenalist) deserializeArenas();
config.save();
enabled = tmp;
}
/**
* Serialize the global settings.
*/
public void serializeSettings()
{
String settings = "global-settings.";
config.setProperty(settings + "enabled", enabled);
config.save();
}
/**
* Serialize all arena configs.
*/
public void serializeArenas()
{
for (Arena arena : arenas)
arena.serializeConfig();
}
/**
* Deserialize all arena configs. Updates the arena list to
* include only the current arenas (not ones added in the
* actual file) that are also in the config-file.
*/
public void deserializeArenas()
{
// Get only the arenas in the config.
Set<String> strings = config.getKeys("arenas");
if (strings == null)
return;
// Get their Arena objects.
List<Arena> configArenas = new LinkedList<Arena>();
for (String s : strings)
if (getArenaWithName(s) != null)
configArenas.add(getArenaWithName(s));
// Remove all Arenas no longer in the config.
arenas.retainAll(configArenas);
for (Arena arena : arenas)
arena.deserializeConfig();
// Make sure to update the selected arena to a valid one.
if (!arenas.contains(selectedArena) && arenas.size() >= 1)
selectedArena = arenas.get(0);
}
public void updateSettings() { update(true, false, false); }
public void updateClasses() { update(false, true, false); }
public void updateArenas() { update(false, false, true); }
public void updateAll() { update(true, true, true); }
}

78
src/com/garbagemule/MobArena/ArenaPlayer.java
View File

@ -1,59 +1,63 @@
package com.garbagemule.MobArena;
import java.util.LinkedList;
import java.util.List;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import com.garbagemule.MobArena.ArenaPlayerStatistics;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.framework.Arena;
public class ArenaPlayer
{
public MobArena plugin;
public Player player;
public String className;
public Arena arena;
public List<ItemStack> rewards;
public List<Block> blocks;
private Player player;
private ArenaClass arenaClass;
private ArenaPlayerStatistics stats;
protected boolean isDead, inArena, inLobby, inSpec, isReady;
public ArenaPlayer(Player player, Arena arena, MobArena plugin)
{
private boolean isDead;
//private List<ItemStack> rewards;
//private List<Block> blocks;
public ArenaPlayer(Player player, Arena arena, MobArena plugin) {
this.player = player;
this.arena = arena;
this.plugin = plugin;
className = arena.classMap.get(player);
rewards = new LinkedList<ItemStack>();
blocks = new LinkedList<Block>();
stats = new ArenaPlayerStatistics(this);
}
public Player getPlayer() { return player; }
public Arena getArena() { return arena; }
public String getClassName() { return className; }
public Player getPlayer() {
return player;
}
public ArenaClass getArenaClass() {
return arenaClass;
}
public void setArenaClass(ArenaClass arenaClass) {
this.arenaClass = arenaClass;
}
/**
* Check if the player is "dead", i.e. died or not.
* @return true, if the player is either a spectator or played and died, false otherwise
*/
public boolean isDead()
{
public boolean isDead() {
return isDead;
}
/**
* Set the player's death status.
* @param value true, if the player is dead, false otherwise
*/
public void setDead(boolean value)
{
public void setDead(boolean value) {
isDead = value;
}
public ArenaPlayerStatistics getStats() { return stats; }
public void resetStats() {
if (stats != null) {
stats.reset();
return;
}
stats = new ArenaPlayerStatistics(this);
}
public ArenaPlayerStatistics getStats() {
return stats;
}
}

179
src/com/garbagemule/MobArena/ArenaPlayerStatistics.java
View File

@ -1,91 +1,130 @@
package com.garbagemule.MobArena;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.ArenaPlayer;
import com.garbagemule.MobArena.ArenaPlayerStatistics;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.util.MutableInt;
public class ArenaPlayerStatistics
{
private String playerName, className;
private ArenaPlayer player;
public int kills, dmgDone, dmgTaken, swings, hits, lastWave;
public ArenaPlayerStatistics(ArenaPlayer player)
{
this.player = player;
private String playerName, className;
private Map<String, MutableInt> ints;
public ArenaPlayerStatistics(ArenaPlayer player) {
this.player = player;
this.playerName = player.getPlayer().getName();
this.className = player.getClassName();
this.className = player.getArenaClass().getName();
reset();
}
public ArenaPlayerStatistics(Player p, Arena arena, MobArena plugin)
{
public void reset() {
if (ints == null) {
ints = new HashMap<String, MutableInt>();
}
ints.clear();
ints.put("kills", new MutableInt());
ints.put("dmgDone", new MutableInt());
ints.put("dmgTaken", new MutableInt());
ints.put("swings", new MutableInt());
ints.put("hits", new MutableInt());
ints.put("lastWave", new MutableInt());
}
public ArenaPlayerStatistics(Player p, Arena arena, MobArena plugin) {
this(new ArenaPlayer(p, arena, plugin));
}
public ArenaPlayer getArenaPlayer()
{
public ArenaPlayer getArenaPlayer() {
return player;
}
public static Comparator<ArenaPlayerStatistics> killComparator()
{
return new Comparator<ArenaPlayerStatistics>()
{
public int compare(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2)
{
if (s1.kills > s2.kills)
return -1;
else if (s1.kills < s2.kills)
return 1;
public String getPlayerName() {
return playerName;
}
public String getClassName() {
return className;
}
public int getInt(String s) {
return ints.get(s).value();
}
public void inc(String s) {
ints.get(s).inc();
}
public void add(String s, int amount) {
ints.get(s).add(amount);
}
public static Comparator<ArenaPlayerStatistics> killComparator() {
return new Comparator<ArenaPlayerStatistics>() {
public int compare(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2) {
int s1kills = s1.getInt("kills");
int s2kills = s2.getInt("kills");
if (s1kills == s2kills)
return 0;
}
};
return (s1kills > s2kills ? -1 : 1);
}
};
}
private static int compareKills(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2)
{
if (s1.kills > s2.kills)
return -1;
else if (s1.kills < s2.kills)
return 1;
return 0;
public static Comparator<ArenaPlayerStatistics> waveComparator() {
return new Comparator<ArenaPlayerStatistics>() {
public int compare(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2) {
int result = compareWaves(s1, s2);
if (result != 0)
return result;
return compareKills(s1, s2);
}
};
}
public static Comparator<ArenaPlayerStatistics> waveComparator()
{
return new Comparator<ArenaPlayerStatistics>()
{
public int compare(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2)
{
int result = compareWaves(s1, s2);
if (result != 0) return result;
return compareKills(s1, s2);
}
};
}
private static int compareWaves(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2)
{
if (s1.lastWave > s2.lastWave)
return -1;
else if (s1.lastWave < s2.lastWave)
return 1;
return 0;
}
public static Comparator<ArenaPlayerStatistics> dmgDoneComparator()
{
return new Comparator<ArenaPlayerStatistics>()
{
public int compare(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2)
{
if (s1.dmgDone > s2.dmgDone)
return -1;
else if (s1.dmgDone < s2.dmgDone)
return 1;
public static Comparator<ArenaPlayerStatistics> dmgDoneComparator() {
return new Comparator<ArenaPlayerStatistics>() {
public int compare(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2) {
int s1dmgDone = s1.getInt("dmgDone");
int s2dmgDone = s2.getInt("dmgDone");
if (s1dmgDone == s2dmgDone)
return 0;
}
};
return (s1dmgDone > s2dmgDone ? -1 : 1);
}
};
}
private static int compareKills(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2) {
int s1kills = s1.getInt("kills");
int s2kills = s2.getInt("kills");
if (s1kills == s2kills)
return 0;
return (s1kills > s2kills ? -1 : 1);
}
private static int compareWaves(ArenaPlayerStatistics s1, ArenaPlayerStatistics s2) {
int s1wave = s1.getInt("lastWave");
int s2wave = s2.getInt("lastWave");
if (s1wave == s2wave)
return 0;
return (s1wave > s2wave ? -1 : 1);
}
}

1413
src/com/garbagemule/MobArena/ArenaStandard.java
View File

File diff suppressed because it is too large Load Diff

84
src/com/garbagemule/MobArena/MABlockListener.java
View File

@ -1,84 +0,0 @@
package com.garbagemule.MobArena;
import org.bukkit.ChatColor;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockIgniteEvent;
import org.bukkit.event.block.BlockListener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.block.SignChangeEvent;
import com.garbagemule.MobArena.leaderboards.Stats;
public class MABlockListener extends BlockListener
{
private ArenaMaster am;
public MABlockListener(ArenaMaster am)
{
this.am = am;
}
public void onBlockBreak(BlockBreakEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onBlockBreak(event);
}
public void onBlockBurn(BlockBurnEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onBlockBurn(event);
}
public void onBlockPlace(BlockPlaceEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onBlockPlace(event);
}
public void onBlockIgnite(BlockIgniteEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onBlockIgnite(event);
}
public void onSignChange(SignChangeEvent event)
{
if (!event.getPlayer().hasPermission("mobarena.setup.leaderboards"))
return;
if (event.getLine(0).startsWith("[MA]"))
{
String text = event.getLine(0).substring((4));
Arena arena;
Stats stat;
if ((arena = am.getArenaWithName(text)) != null)
{
arena.eventListener.onSignChange(event);
setSignLines(event, ChatColor.GREEN + "MobArena", ChatColor.YELLOW + arena.arenaName(), ChatColor.AQUA + "Players", "---------------");
}
else if ((stat = Stats.fromString(text)) != null)
{
setSignLines(event, ChatColor.GREEN + "", "", ChatColor.AQUA + stat.getFullName(), "---------------");
MAUtils.tellPlayer(event.getPlayer(), "Stat sign created.");
}
}
}
private void setSignLines(SignChangeEvent event, String s1, String s2, String s3, String s4)
{
event.setLine(0, s1);
event.setLine(1, s2);
event.setLine(2, s3);
event.setLine(3, s4);
}
/*
public void onBlockPhysics(BlockPhysicsEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onBlockPhysics(event);
}
*/
}

149
src/com/garbagemule/MobArena/MAClass.java
View File

@ -1,149 +0,0 @@
package com.garbagemule.MobArena;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
public class MAClass
{
private String name;
private List<ItemStack> items, armor;
private Map<String,Boolean> perms;
public MAClass(String name)
{
this.name = name;
this.items = new LinkedList<ItemStack>();
this.armor = new LinkedList<ItemStack>();
this.perms = new HashMap<String,Boolean>();
}
public MAClass(String name, List<ItemStack> items, List<ItemStack> armor)
{
this.name = name;
this.items = items;
this.armor = armor;
this.perms = new HashMap<String,Boolean>();
sortArmor();
immunizeWeapons();
}
public String getName()
{
return name;
}
public List<ItemStack> getItems()
{
return items;
}
public void setItems(List<ItemStack> items)
{
this.items = items;
immunizeWeapons();
}
public void setArmor(List<ItemStack> armor)
{
this.armor = armor;
sortArmor();
}
public void setPerms(Map<String,Boolean> perms)
{
this.perms = perms;
}
public void giveItems(Player p)
{
PlayerInventory inv = p.getInventory();
for (ItemStack stack : items)
{
inv.addItem(stack.clone());
}
}
public void giveArmor(Player p)
{
PlayerInventory inv = p.getInventory();
inv.setHelmet (armor.get(0));
inv.setChestplate(armor.get(1));
inv.setLeggings (armor.get(2));
inv.setBoots (armor.get(3));
}
private void sortArmor()
{
ItemStack s0 = null, s1 = null, s2 = null, s3 = null;
for (ItemStack stack : armor)
{
if (isHelmet(stack))
s0 = stack;
else if (isChestplate(stack))
s1 = stack;
else if (isLeggings(stack))
s2 = stack;
else if (isBoots(stack))
s3 = stack;
}
armor.set(0, s0);
armor.set(1, s1);
armor.set(2, s2);
armor.set(3, s3);
}
private void immunizeWeapons()
{
for (ItemStack stack : items)
{
}
}
private boolean isHelmet(ItemStack stack)
{
return (!isChestplate(stack) && !isLeggings(stack) && !isBoots(stack));
}
private boolean isChestplate(ItemStack stack)
{
return matches(stack, 299, 303, 307, 311, 315);
}
private boolean isLeggings(ItemStack stack)
{
return matches(stack, 300, 304, 308, 312, 316);
}
private boolean isBoots(ItemStack stack)
{
return matches(stack, 301, 305, 309, 313, 317);
}
private boolean isWeapon(ItemStack stack)
{
return matches(stack, 256, 257, 258, 267, 268, 269, 270, 271, 272, 273,
274, 275, 276, 277, 278, 279, 283, 284, 285, 286,
290, 291, 292, 293, 294, 346);
}
private boolean matches(ItemStack stack, int... ids)
{
int id = stack.getTypeId();
for (int i : ids)
if (id == i)
return true;
return false;
}
}

1309
src/com/garbagemule/MobArena/MACommands.java
View File

File diff suppressed because it is too large Load Diff

79
src/com/garbagemule/MobArena/MAEntityListener.java
View File

@ -1,79 +0,0 @@
package com.garbagemule.MobArena;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.entity.EndermanPickupEvent;
import org.bukkit.event.entity.EndermanPlaceEvent;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.entity.EntityListener;
import org.bukkit.event.entity.EntityRegainHealthEvent;
import org.bukkit.event.entity.EntityTargetEvent;
import com.garbagemule.MobArena.Arena;
import com.garbagemule.MobArena.ArenaMaster;
public class MAEntityListener extends EntityListener
{
private ArenaMaster am;
public MAEntityListener(ArenaMaster am)
{
this.am = am;
}
public void onEntityRegainHealth(EntityRegainHealthEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEntityRegainHealth(event);
}
public void onEntityDeath(EntityDeathEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEntityDeath(event);
}
public void onEntityDamage(EntityDamageEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEntityDamage(event);
}
public void onCreatureSpawn(CreatureSpawnEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onCreatureSpawn(event);
}
public void onEntityExplode(EntityExplodeEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEntityExplode(event);
}
public void onEntityCombust(EntityCombustEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEntityCombust(event);
}
public void onEntityTarget(EntityTargetEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEntityTarget(event);
}
public void onEndermanPickup(EndermanPickupEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEndermanPickup(event);
}
public void onEndermanPickup(EndermanPlaceEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onEndermanPlace(event);
}
}

724
src/com/garbagemule/MobArena/MAListener.java
View File

@ -1,724 +0,0 @@
package com.garbagemule.MobArena;
import java.util.LinkedList;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.ContainerBlock;
import org.bukkit.block.Sign;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Projectile;
import org.bukkit.entity.Slime;
import org.bukkit.entity.Wolf;
import org.bukkit.event.Event.Result;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockEvent;
import org.bukkit.event.block.BlockIgniteEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.block.SignChangeEvent;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.entity.EndermanPickupEvent;
import org.bukkit.event.entity.EndermanPlaceEvent;
import org.bukkit.event.entity.EntityCombustEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.entity.EntityRegainHealthEvent;
import org.bukkit.event.entity.EntityTargetEvent;
import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
import org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason;
import org.bukkit.event.entity.EntityTargetEvent.TargetReason;
import org.bukkit.event.player.PlayerAnimationEvent;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.material.Attachable;
import org.bukkit.material.Bed;
import org.bukkit.material.Door;
import org.bukkit.material.Redstone;
import com.garbagemule.MobArena.leaderboards.Leaderboard;
import com.garbagemule.MobArena.repairable.*;
public class MAListener implements ArenaListener
{
private MobArena plugin;
private Arena arena;
public MAListener(Arena arena, MobArena plugin)
{
this.arena = arena;
this.plugin = plugin;
}
public void onBlockBreak(BlockBreakEvent event)
{
if (onBlockDestroy(event))
return;
event.setCancelled(true);
}
public void onBlockBurn(BlockBurnEvent event)
{
if (onBlockDestroy(event))
return;
event.setCancelled(true);
}
private boolean onBlockDestroy(BlockEvent event)
{
if (!arena.inRegion(event.getBlock().getLocation()) || arena.edit || (!arena.protect && arena.running))
return true;
Block b = event.getBlock();
if (arena.blocks.remove(b) || b.getType() == Material.TNT)
return true;
if (arena.softRestore && arena.running)
{
BlockState state = b.getState();
Repairable r = null;
if (state instanceof ContainerBlock)
r = new RepairableContainer(state);
else if (state instanceof Sign)
r = new RepairableSign(state);
else if (state.getData() instanceof Attachable)
r = new RepairableAttachable(state);
else
r = new RepairableBlock(state);
arena.repairables.add(r);
if (!arena.softRestoreDrops)
b.setTypeId(0);
return true;
}
return false;
}
public void onBlockPlace(BlockPlaceEvent event)
{
Block b = event.getBlock();
if (!arena.inRegion(b.getLocation()) || arena.edit)
return;
if (arena.running && arena.inArena(event.getPlayer()))
{
arena.blocks.add(b);
Material mat = b.getType();
if (mat == Material.WOODEN_DOOR || mat == Material.IRON_DOOR_BLOCK)
arena.blocks.add(b.getRelative(0,1,0));
return;
}
// If the arena isn't running, or if the player isn't in the arena, cancel.
event.setCancelled(true);
}
public void onBlockIgnite(BlockIgniteEvent event)
{
if (!arena.inRegion(event.getBlock().getLocation()))
return;
switch (event.getCause())
{
case LIGHTNING:
event.setCancelled(true);
break;
case SPREAD:
case FLINT_AND_STEEL:
if (arena.running)
arena.blocks.add(event.getBlock());
else
event.setCancelled(true);
break;
default:
break;
}
}
public void onSignChange(SignChangeEvent event)
{
arena.leaderboard = new Leaderboard(plugin, arena, event.getBlock().getLocation());
MAUtils.setArenaCoord(plugin.getMAConfig(), arena, "leaderboard", event.getBlock().getLocation());
MAUtils.tellPlayer(event.getPlayer(), "Leaderboard made. Now set up the stat signs!");
}
public void onCreatureSpawn(CreatureSpawnEvent event)
{
if (!arena.inRegion(event.getLocation())) // || event.getSpawnReason() == SpawnReason.CUSTOM)
return;
LivingEntity entity = (LivingEntity) event.getEntity();
if (arena.running && entity instanceof Slime)
arena.monsters.add(entity);
// If running == true, setCancelled(false), and vice versa.
event.setCancelled(!arena.running);
}
public void onEntityExplode(EntityExplodeEvent event)
{
if (!arena.monsters.contains(event.getEntity()) && !arena.inRegionRadius(event.getLocation(), 10))
return;
arena.monsters.remove(event.getEntity());
// Cancel if the arena isn't running
if (!arena.running)
{
event.setCancelled(true);
return;
}
// Uncancel, just in case.
event.setCancelled(false);
// If the arena isn't destructible, just clear the blocklist.
if (!arena.softRestore && arena.protect)
{
List<Block> blocks = new LinkedList<Block>(arena.blocks);
event.blockList().retainAll(blocks);
return;
}
if (!arena.softRestoreDrops)
event.setYield(0);
// Handle all the blocks in the block list.
for (Block b : event.blockList())
{
BlockState state = b.getState();
if (state.getData() instanceof Door && ((Door) state.getData()).isTopHalf())
state = b.getRelative(BlockFace.DOWN).getState();
else if (state.getData() instanceof Bed && ((Bed) state.getData()).isHeadOfBed())
state = b.getRelative(((Bed) state.getData()).getFacing().getOppositeFace()).getState();
// Create a Repairable from the block.
Repairable r = null;
if (state instanceof ContainerBlock)
r = new RepairableContainer(state);
else if (state instanceof Sign)
r = new RepairableSign(state);
else if (state.getData() instanceof Bed)
r = new RepairableBed(state);
else if (state.getData() instanceof Door)
r = new RepairableDoor(state);
else if (state.getData() instanceof Attachable || state.getData() instanceof Redstone)
r = new RepairableAttachable(state);
else
r = new RepairableBlock(state);
// Cakes and liquids should just get removed. If player-placed block, drop as item.
Material mat = state.getType();
if (mat == Material.CAKE_BLOCK || mat == Material.WATER || mat == Material.LAVA)
arena.blocks.remove(b);
else if (arena.blocks.remove(b))
arena.world.dropItemNaturally(b.getLocation(), new ItemStack(state.getTypeId(), 1));
else if (arena.softRestore)
arena.repairables.add(r);
else
arena.queueRepairable(r);
}
}
/******************************************************
*
* DEATH LISTENERS
*
******************************************************/
public void onEntityDeath(EntityDeathEvent event)
{
if (event.getEntity() instanceof Player)
onPlayerDeath(event, (Player) event.getEntity());
else if (arena.monsters.remove(event.getEntity()))
onMonsterDeath(event);
}
private void onPlayerDeath(EntityDeathEvent event, Player player)
{
if (arena.inArena(player) || arena.lobbyPlayers.contains(player))
{
event.getDrops().clear();
arena.playerDeath(player);
}
}
private void onMonsterDeath(EntityDeathEvent event)
{
EntityDamageEvent e1 = event.getEntity().getLastDamageCause();
EntityDamageByEntityEvent e2 = (e1 instanceof EntityDamageByEntityEvent) ? (EntityDamageByEntityEvent) e1 : null;
Entity damager = (e2 != null) ? e2.getDamager() : null;
if (damager instanceof Player)
arena.playerKill((Player) damager);
event.getDrops().clear();
arena.resetIdleTimer();
return;
}
/******************************************************
*
* DAMAGE LISTENERS
*
******************************************************/
public void onEntityDamage(EntityDamageEvent event)
{
if (!arena.running) return;
EntityDamageByEntityEvent e = (event instanceof EntityDamageByEntityEvent) ? (EntityDamageByEntityEvent) event : null;
Entity damagee = event.getEntity();
Entity damager = null;
if (e != null)
{
damager = e.getDamager();
if (damager instanceof Projectile)
damager = ((Projectile) damager).getShooter();
}
event.setCancelled(false);
// Pet wolf
if (damagee instanceof Wolf && arena.pets.contains(damagee))
onPetDamage(event, (Wolf) damagee, damager);
// Player
else if (damagee instanceof Player)
onPlayerDamage(event, (Player) damagee, damager);
// Monster
else if (arena.monsters.contains(damagee))
onMonsterDamage(event, damagee, damager);
}
private void onPlayerDamage(EntityDamageEvent event, Player player, Entity damager)
{
// Cancel all damage in the lobby
if (arena.lobbyPlayers.contains(player))
event.setCancelled(true);
// If not in the lobby or the arena, return
else if (!arena.inArena(player))
return;
// Cancel block explosion damage if detonate-damage: false
else if (!arena.detDamage && event.getCause() == DamageCause.BLOCK_EXPLOSION)
event.setCancelled(true);
// If PvP is disabled and damager is a player, cancel damage
else if (!arena.pvp && damager instanceof Player)
event.setCancelled(true);
// Log damage
if (!event.isCancelled())
arena.arenaPlayerMap.get(player).getStats().dmgTaken += event.getDamage();
}
private void onPetDamage(EntityDamageEvent event, Wolf pet, Entity damager)
{
if (arena.hellhounds && (damager == null || damager instanceof Player))
pet.setFireTicks(32768);
event.setCancelled(true);
}
private void onMonsterDamage(EntityDamageEvent event, Entity monster, Entity damager)
{
if (damager instanceof Player)
{
Player p = (Player) damager;
if (!arena.inArena(p))
{
event.setCancelled(true);
return;
}
arena.arenaPlayerMap.get(p).getStats().dmgDone += event.getDamage();
arena.arenaPlayerMap.get(p).getStats().hits++;
}
else if (damager instanceof Wolf && arena.pets.contains(damager))
{
event.setDamage(1);
arena.arenaPlayerMap.get((Player) ((Wolf) damager).getOwner()).getStats().dmgDone += event.getDamage();
}
else if (damager instanceof LivingEntity)
{
if (!arena.monsterInfight)
event.setCancelled(true);
}
// Boss
if (arena.bossWave != null && monster.equals(arena.bossWave.getEntity()))
{
if (event.getCause() == DamageCause.LIGHTNING)
{
event.setCancelled(true);
return;
}
// Subtract boss health, and reset actual entity health
arena.bossWave.subtractHealth(event.getDamage());
arena.bossWave.getEntity().setHealth(arena.bossWave.getEntity().getMaxHealth());
// Set damage to 1 for knockback and feedback
event.setDamage(1);
// If the boss is dead, remove the entity and create an explosion!
if (arena.bossWave.getHealth() <= 0)
{
arena.bossWave.clear();
arena.bossWave = null;
}
else if (arena.bossWave.getHealth() <= 100 && !arena.bossWave.isLowHealthAnnounced())
{
MAUtils.tellAll(arena, Msg.WAVE_BOSS_LOW_HEALTH);
arena.bossWave.setLowHealthAnnounced(true);
}
}
}
public void onEntityCombust(EntityCombustEvent event)
{
if (arena.monsters.contains(event.getEntity()))
event.setCancelled(true);
}
public void onEntityTarget(EntityTargetEvent event)
{
if (!arena.running || event.isCancelled())
return;
if (arena.pets.contains(event.getEntity()))
{
if (event.getReason() != TargetReason.TARGET_ATTACKED_OWNER && event.getReason() != TargetReason.OWNER_ATTACKED_TARGET)
return;
if (!(event.getTarget() instanceof Player))
return;
// If the target is a player, cancel.
event.setCancelled(true);
}
else if (arena.monsters.contains(event.getEntity()))
{
if (event.getReason() == TargetReason.FORGOT_TARGET)
event.setTarget(MAUtils.getClosestPlayer(event.getEntity(), arena));
else if (event.getReason() == TargetReason.TARGET_DIED)
event.setTarget(MAUtils.getClosestPlayer(event.getEntity(), arena));
else if (event.getReason() == TargetReason.TARGET_ATTACKED_ENTITY)
if (arena.pets.contains(event.getTarget()))
event.setCancelled(true);
else if (event.getReason() == TargetReason.CLOSEST_PLAYER)
if (!arena.inArena((Player) event.getTarget()))
event.setCancelled(true);
}
}
public void onEndermanPickup(EndermanPickupEvent event)
{
if (arena.inRegion(event.getBlock().getLocation()))
event.setCancelled(true);
}
public void onEndermanPlace(EndermanPlaceEvent event)
{
if (arena.inRegion(event.getLocation()))
event.setCancelled(true);
}
public void onEntityRegainHealth(EntityRegainHealthEvent event)
{
if (!arena.running) return;
if (!(event.getEntity() instanceof Player) || !arena.inArena((Player)event.getEntity()))
return;
if (event.getRegainReason() == RegainReason.REGEN)
event.setCancelled(true);
}
public void onPlayerAnimation(PlayerAnimationEvent event)
{
if (!arena.running || !arena.inArena(event.getPlayer()))
return;
arena.arenaPlayerMap.get(event.getPlayer()).getStats().swings++;
}
public void onPlayerDropItem(PlayerDropItemEvent event)
{
Player p = event.getPlayer();
// Player is in the lobby
if (arena.inLobby(p))
{
MAUtils.tellPlayer(p, Msg.LOBBY_DROP_ITEM);
event.setCancelled(true);
}
// Player is in the arena
else if (arena.inArena(p))
{
if (!arena.shareInArena)
{
MAUtils.tellPlayer(p, Msg.LOBBY_DROP_ITEM);
event.setCancelled(true);
}
}
// Player died/left
else if (p.getLocation().equals(arena.spectatorLoc) || p.getLocation().equals(arena.locations.get(p)))
{
MobArena.warning("Player '" + p.getName() + "' tried to steal item " + event.getItemDrop().getItemStack().getType());
event.getItemDrop().remove();
}
// Player is in the spectator area
else if (arena.specPlayers.contains(p))
{
MAUtils.tellPlayer(p, Msg.LOBBY_DROP_ITEM);
event.setCancelled(true);
}
}
public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event)
{
if (!arena.readyPlayers.contains(event.getPlayer()) && !arena.inArena(event.getPlayer()))
return;
if (!arena.running)
{
event.getBlockClicked().getRelative(event.getBlockFace()).setTypeId(0);
event.setCancelled(true);
return;
}
Block liquid = event.getBlockClicked().getRelative(event.getBlockFace());
arena.blocks.add(liquid);
}
public void onPlayerInteract(PlayerInteractEvent event)
{
Player p = event.getPlayer();
if (arena.inArena(p) || !arena.inLobby(p))
return;
// Player is in the lobby, so disallow using items.
Action a = event.getAction();
if (a == Action.RIGHT_CLICK_AIR || a == Action.RIGHT_CLICK_BLOCK)
{
event.setUseItemInHand(Result.DENY);
event.setCancelled(true);
}
// If there's no block involved, just return.
if (!event.hasBlock())
return;
// Iron block
if (event.getClickedBlock().getTypeId() == 42)
handleReadyBlock(p);
// Sign
else if (event.getClickedBlock().getState() instanceof Sign)
{
Sign sign = (Sign) event.getClickedBlock().getState();
handleSign(sign, p);
}
}
private void handleReadyBlock(Player p)
{
if (arena.classMap.containsKey(p))
{
MAUtils.tellPlayer(p, Msg.LOBBY_PLAYER_READY);
arena.playerReady(p);
}
else MAUtils.tellPlayer(p, Msg.LOBBY_PICK_CLASS);
}
private void handleSign(Sign sign, Player p)
{
// Check if the first line is a class name.
String className = ChatColor.stripColor(sign.getLine(0));
if (!arena.classes.contains(className) && !className.equalsIgnoreCase("random"))
return;
// Check for permission.
if (!plugin.has(p, "mobarena.classes." + className) && !className.equalsIgnoreCase("random"))
{
MAUtils.tellPlayer(p, Msg.LOBBY_CLASS_PERMISSION);
return;
}
// Delay the inventory stuff to ensure that right-clicking works.
delayAssignClass(p, className);
}
private void delayAssignClass(final Player p, final String className)
{
Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(plugin,
new Runnable()
{
public void run()
{
arena.assignClass(p, className);
if (!className.equalsIgnoreCase("random"))
MAUtils.tellPlayer(p, Msg.LOBBY_CLASS_PICKED, className, arena.classItems.get(className).get(0).getType());
else
MAUtils.tellPlayer(p, Msg.LOBBY_CLASS_RANDOM);
}
});
}
public void onPlayerQuit(PlayerQuitEvent event)
{
Player p = event.getPlayer();
if (!arena.enabled || (!arena.inArena(p) && !arena.inLobby(p)))
return;
arena.playerLeave(p);
}
public void onPlayerKick(PlayerKickEvent event)
{
Player p = event.getPlayer();
if (!arena.enabled || (!arena.inArena(p) && !arena.inLobby(p)))
return;
arena.playerLeave(p);
}
public void onPlayerTeleport(PlayerTeleportEvent event)
{
if (!arena.enabled || !arena.setup || arena.allowWarp || arena.edit)
return;
Location to = event.getTo();
Location from = event.getFrom();
Player p = event.getPlayer();
if (arena.inRegion(from))
{
// Covers the case in which both locations are in the arena.
if ((arena.inRegion(to) && arena.running) || isWarp(to) || to.equals(arena.locations.get(p)))
return;
MAUtils.tellPlayer(p, Msg.WARP_FROM_ARENA);
event.setCancelled(true);
}
else if (arena.inRegion(to))
{
if (isWarp(from) || isWarp(to) || to.equals(arena.locations.get(p)))
return;
MAUtils.tellPlayer(p, Msg.WARP_TO_ARENA);
event.setCancelled(true);
}
}
private boolean isWarp(Location l)
{
return l.equals(arena.arenaLoc) || l.equals(arena.lobbyLoc) || l.equals(arena.spectatorLoc);
}
/*public void onPlayerTeleport(PlayerTeleportEvent event)
{
if (!arena.running || arena.edit || !arena.enabled || !arena.setup || arena.allowWarp)
return;
Location to = event.getTo();
Location from = event.getFrom();
if (!arena.inRegion(to) && !arena.inRegion(from))
return;
Player p = event.getPlayer();
Location old = arena.locations.get(p);
if (arena.inArena(p) || arena.inLobby(p) || arena.specPlayers.contains(p))
{
if (arena.inRegion(from))
{
if (arena.inRegion(to) || to.equals(arena.arenaLoc) || to.equals(arena.lobbyLoc) || to.equals(arena.spectatorLoc) || to.equals(old))
return;
MAUtils.tellPlayer(p, Msg.WARP_FROM_ARENA);
event.setCancelled(true);
return;
}
if (arena.inRegion(to))
{
if (to.equals(arena.arenaLoc) || to.equals(arena.lobbyLoc) || to.equals(arena.spectatorLoc) || to.equals(old))
return;
MAUtils.tellPlayer(p, Msg.WARP_TO_ARENA);
event.setCancelled(true);
return;
}
return;
}
if (arena.running && arena.inRegion(to))
{
event.setCancelled(true);
return;
}
}*/
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event)
{
Player p = event.getPlayer();
if (!arena.inArena(p) && !arena.inLobby(p))
return;
String[] args = event.getMessage().split(" ");
if ((args.length > 1 && MACommands.COMMANDS.contains(args[1].trim())) ||
MACommands.ALLOWED_COMMANDS.contains(event.getMessage().substring(1).trim()) ||
MACommands.ALLOWED_COMMANDS.contains(args[0]))
return;
event.setCancelled(true);
MAUtils.tellPlayer(p, Msg.MISC_COMMAND_NOT_ALLOWED);
}
}

68
src/com/garbagemule/MobArena/MAMessages.java
View File

@ -7,104 +7,110 @@ import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.Msg;
public class MAMessages
{
public static void init(MobArenaPlugin plugin) {
public static void init(MobArena plugin) {
// Grab the file
File msgFile = new File(MobArena.dir, "anouncements.properties");
File msgFile = new File(plugin.getDataFolder(), "announcements.properties");
// If it couldn't be loaded for some reason
if (!load(msgFile))
if (!load(plugin, msgFile))
return;
// Otherwise, start parsing!
parseFile(msgFile);
parseFile(plugin, msgFile);
}
private static boolean load(File file) {
private static boolean load(MobArena plugin, File file) {
// If the file exists, continue on!
if (file.exists()) {
return true;
}
// Otherwise, create it, and populate it with the defaults.
try {
file.createNewFile();
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
for (Msg m : Msg.values()) {
if (m.hasSpoutMsg()) {
bw.write(m.name() + "=" + m + "|" + m.toSpoutString());
} else {
}
else {
bw.write(m.name() + "=" + m);
}
bw.newLine();
}
bw.close();
return true;
}
catch (Exception e) {
MobArena.warning("Couldn't initialize announcements-file. Using defaults.");
plugin.warning("Couldn't initialize announcements-file. Using defaults.");
return false;
}
}
private static void parseFile(File file) {
private static void parseFile(MobArena plugin, File file) {
try {
FileInputStream fis = new FileInputStream(file);
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr);
BufferedReader br = new BufferedReader(isr);
// Check for BOM character.
br.mark(1);
int bom = br.read();
if (bom != 65279)
br.reset();
String s;
while ((s = br.readLine()) != null)
process(s);
process(plugin, s);
br.close();
}
catch (Exception e) {
e.printStackTrace();
MobArena.warning("Problem with announcements-file. Using defaults.");
plugin.warning("Problem with announcements-file. Using defaults.");
return;
}
}
/**
* Helper-method for parsing the strings from the
* announcements-file.
*/
private static void process(String s) {
private static void process(MobArena plugin, String s) {
// If the line ends with = or |, just add a space
if (s.endsWith("=") || s.endsWith("|")) s += " ";
if (s.endsWith("=") || s.endsWith("|")) {
s += " ";
}
// Split the string by the equals-sign.
String[] split = s.split("=");
if (split.length != 2) {
MobArena.warning("Couldn't parse \"" + s + "\". Check announcements-file.");
plugin.warning("Couldn't parse \"" + s + "\". Check announcements-file.");
return;
}
// Split the value by the pipe-sign.
String[] vals = split[1].split("\\|");
// For simplicity...
String key = split[0];
String val = vals.length == 2 ? vals[0] : split[1];
String spoutVal = vals.length == 2 ? vals[1] : null;
try {
Msg msg = Msg.valueOf(key);
msg.set(val);
msg.setSpout(spoutVal);
}
catch (Exception e) {
MobArena.warning(key + " is not a valid key. Check announcements-file.");
plugin.warning(key + " is not a valid key. Check announcements-file.");
return;
}
}

96
src/com/garbagemule/MobArena/MAPlayerListener.java
View File

@ -1,96 +0,0 @@
package com.garbagemule.MobArena;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerAnimationEvent;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerListener;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
public class MAPlayerListener extends PlayerListener
{
private MobArena plugin;
private ArenaMaster am;
public MAPlayerListener(MobArena plugin, ArenaMaster am)
{
this.plugin = plugin;
this.am = am;
}
public void onPlayerAnimation(PlayerAnimationEvent event)
{
if (!am.enabled) return;
for (Arena arena : am.arenas)
arena.eventListener.onPlayerAnimation(event);
}
public void onPlayerInteract(PlayerInteractEvent event)
{
if (!am.enabled) return;
for (Arena arena : am.arenas)
arena.eventListener.onPlayerInteract(event);
}
public void onPlayerDropItem(PlayerDropItemEvent event)
{
if (!am.enabled) return;
for (Arena arena : am.arenas)
arena.eventListener.onPlayerDropItem(event);
}
public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event)
{
if (!am.enabled) return;
for (Arena arena : am.arenas)
arena.eventListener.onPlayerBucketEmpty(event);
}
public void onPlayerTeleport(PlayerTeleportEvent event)
{
if (!am.enabled) return;
for (Arena arena : am.arenas)
arena.eventListener.onPlayerTeleport(event);
}
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event)
{
if (!am.enabled) return;
for (Arena arena : am.arenas)
arena.eventListener.onPlayerCommandPreprocess(event);
}
public void onPlayerQuit(PlayerQuitEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onPlayerQuit(event);
}
public void onPlayerKick(PlayerKickEvent event)
{
for (Arena arena : am.arenas)
arena.eventListener.onPlayerKick(event);
}
public void onPlayerJoin(PlayerJoinEvent event)
{
if (!am.updateNotify || !event.getPlayer().isOp()) return;
final Player p = event.getPlayer();
Bukkit.getServer().getScheduler().scheduleAsyncDelayedTask(plugin,
new Runnable()
{
public void run()
{
MAUtils.checkForUpdates(plugin, p, false);
}
}, 60);
}
}

516
src/com/garbagemule/MobArena/MASpawnThread.java
View File

@ -1,283 +1,341 @@
package com.garbagemule.MobArena;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import org.bukkit.Location;
import org.bukkit.entity.Creeper;
import org.bukkit.World;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Creature;
import org.bukkit.entity.Entity;
import org.bukkit.inventory.ItemStack;
import com.garbagemule.MobArena.util.WaveUtils;
import com.garbagemule.MobArena.waves.Wave;
import com.garbagemule.MobArena.ArenaPlayer;
import com.garbagemule.MobArena.MAUtils;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.Msg;
import com.garbagemule.MobArena.events.NewWaveEvent;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.region.ArenaRegion;
import com.garbagemule.MobArena.waves.*;
import com.garbagemule.MobArena.waves.enums.WaveType;
import com.garbagemule.MobArena.waves.types.BossWave;
import com.garbagemule.MobArena.waves.types.SupplyWave;
import com.garbagemule.MobArena.waves.types.UpgradeWave;
/**
* Core class for handling wave spawning.
* Currently, every 4th wave is a special wave, and all other waves
* are default waves. The distribution coefficients are used to spread
* out the distribution of each default monster however the server
* host chooses. It is possible to create default waves that consist of
* only one type of monster, or ones that have no creepers, for example.
*/
public class MASpawnThread implements Runnable
{
private MobArena plugin;
private Arena arena;
private int wave, taskId, previousSize, playerCount;
// NEW WAVES
private Wave defaultWave;
private TreeSet<Wave> recurrentWaves;
private TreeSet<Wave> singleWaves;
public MASpawnThread(MobArena plugin, Arena arena)
{
// WAVES
defaultWave = arena.recurrentWaves.first();
recurrentWaves = arena.recurrentWaves;
singleWaves = new TreeSet<Wave>(arena.singleWaves);
this.plugin = plugin;
this.arena = arena;
wave = 1;
playerCount = arena.arenaPlayers.size();
}
public void run()
{
// Clear out all dead monsters in the monster set.
removeDeadMonsters();
// If there are no players in the arena, return.
if (arena.arenaPlayers.isEmpty())
return;
private ArenaRegion region;
private RewardManager rewardManager;
private WaveManager waveManager;
private MonsterManager monsterManager;
// Check if wave needs to be cleared first. If so, return!
if (arena.waveClear && wave > 1 && !arena.monsters.isEmpty())
return;
// Check if we're on a boss wave
if (!arena.waveClear && arena.bossWave != null)
return;
// Grant rewards (if any) for this wave
grantRewards(wave);
// Detonate creepers if needed
detonateCreepers(arena.detCreepers);
// Check if this is the final wave, in which case, end instead of spawn
if (wave > 1 && wave == arena.finalWave)
{
for (Player p : arena.arenaPlayers)
arena.playerDeath(p);
private int playerCount, monsterLimit;
private boolean waveClear, bossClear;
/**
* Create a new monster spawner for the input arena.
* Note that the arena's WaveManager is reset
* @param plugin a MobArena instance
* @param arena an arena
*/
public MASpawnThread(MobArena plugin, Arena arena) {
this.plugin = plugin;
this.arena = arena;
this.region = arena.getRegion();
this.rewardManager = arena.getRewardManager();
this.waveManager = arena.getWaveManager();
this.monsterManager = arena.getMonsterManager();
reset();
}
/**
* Reset the spawner, so all systems and settings are
* ready for a new session.
*/
public void reset() {
waveManager.reset();
playerCount = arena.getPlayersInArena().size();
monsterLimit = arena.getSettings().getInt("monster-limit", 100);
waveClear = arena.getSettings().getBoolean("clear-wave-before-next", false);
bossClear = arena.getSettings().getBoolean("clear-boss-before-next", false);
}
public void run() {
// If the arena isn't running or if there are no players in it.
if (!arena.isRunning() || arena.getPlayersInArena().isEmpty()) {
return;
}
// Find the wave to spawn
spawnWave(wave);
// Clear out all dead monsters in the monster set.
removeDeadMonsters();
removeCheatingPlayers();
// In case some players were removed, check again.
if (!arena.isRunning()) {
return;
}
// Grab the wave number.
int nextWave = waveManager.getWaveNumber() + 1;
// Check if wave needs to be cleared first. If so, return!
if (!isWaveClear()) {
arena.scheduleTask(this, 60);
return;
}
// Fire off the event. If cancelled, try again in 3 seconds.
NewWaveEvent event = new NewWaveEvent(arena, waveManager.getNext(), nextWave);
plugin.getServer().getPluginManager().callEvent(event);
if (event.isCancelled()) {
arena.scheduleTask(this, 60);
return;
}
// Grant rewards (if any) for the wave about to spawn
grantRewards(nextWave);
// Check if this is the final wave, in which case, end instead of spawn
if (nextWave > 1 && (nextWave - 1) == waveManager.getFinalWave()) {
List<Player> players = new ArrayList<Player>(arena.getPlayersInArena());
for (Player p : players) {
arena.playerLeave(p);
}
return;
}
// Spawn the next wave.
spawnWave(nextWave);
// Update stats
updateStats(wave);
wave++;
if (arena.monsters.isEmpty())
arena.resetIdleTimer();
updateStats(nextWave);
// Reschedule the spawner for the next wave.
arena.scheduleTask(this, arena.getSettings().getInt("wave-interval", 3) * 20);
}
private void removeDeadMonsters()
{
List<Entity> tmp = new LinkedList<Entity>(arena.monsters);
for (Entity e : tmp)
{
if (e == null) continue;
if (e.isDead() || !arena.inRegion(e.getLocation()))
{
arena.monsters.remove(e);
private void spawnWave(int wave) {
Wave w = waveManager.next();
w.announce(arena, wave);
if (w.getType() == WaveType.UPGRADE) {
handleUpgradeWave(w);
return;
}
Map<MACreature, Integer> monsters = w.getMonstersToSpawn(wave, playerCount, arena);
List<Location> spawnpoints = w.getSpawnpoints(arena);
World world = arena.getWorld();
int totalSpawnpoints = spawnpoints.size();
int index = 0;
double mul = w.getHealthMultiplier();
for (Map.Entry<MACreature, Integer> entry : monsters.entrySet()) {
for (int i = 0; i < entry.getValue(); i++, index++) {
// Check if monster limit has been reached.
if (monsterManager.getMonsters().size() >= monsterLimit) {
return;
}
// Grab a spawnpoint
Location spawnpoint = spawnpoints.get(index % totalSpawnpoints);
// Spawn the monster
LivingEntity e = entry.getKey().spawn(arena, world, spawnpoint);
// Add it to the arena.
monsterManager.addMonster(e);
// Set the health.
int health = (int) Math.max(1D, e.getMaxHealth() * mul);
e.setHealth(Math.min(health, e.getMaxHealth()));
// Switch on the type.
switch (w.getType()){
case BOSS:
BossWave bw = (BossWave) w;
int maxHealth = bw.getMaxHealth(playerCount);
MABoss boss = monsterManager.addBoss(e, maxHealth);
bw.addMABoss(boss);
bw.activateAbilities(arena);
break;
case SWARM:
health = (int) (mul < 1D ? e.getMaxHealth() * mul : 1);
health = Math.max(1, health);
e.setHealth(Math.min(health, e.getMaxHealth()));
break;
case SUPPLY:
SupplyWave sw = (SupplyWave) w;
monsterManager.addSupplier(e, sw.getDropList());
break;
default:
break;
}
}
}
}
private void handleUpgradeWave(Wave w) {
UpgradeWave uw = (UpgradeWave) w;
for (Player p : arena.getPlayersInArena()) {
String className = arena.getArenaPlayer(p).getArenaClass().getName();
//String className = arena.getClassOfPlayer(p);
uw.grantItems(p, className);
uw.grantItems(p, "All");
}
}
/**
* Check if the wave is clear for new spawns.
* If clear-boss-before-next: true, bosses must be dead.
* If clear-wave-before-next: true, all monsters must be dead.
* @param wave the next wave number
* @return true, if the wave is "clear" for new spawns.
*/
private boolean isWaveClear() {
// Check for monster limit
if (monsterManager.getMonsters().size() >= monsterLimit) {
return false;
}
// Check for boss clear
if (bossClear && !monsterManager.getBossMonsters().isEmpty()) {
return false;
}
// Check for wave clear
if (waveClear && !monsterManager.getMonsters().isEmpty()) {
return false;
}
// Check for final wave
if (!monsterManager.getMonsters().isEmpty() && waveManager.getWaveNumber() == waveManager.getFinalWave()) {
return false;
}
return true;
}
private void removeDeadMonsters() {
List<Entity> tmp = new ArrayList<Entity>(monsterManager.getMonsters());
for (Entity e : tmp) {
if (e == null) {
continue;
}
if (e.isDead() || !region.contains(e.getLocation())) {
monsterManager.removeMonster(e);
e.remove();
}
}
}
private void grantRewards(int wave)
{
for (Map.Entry<Integer,List<ItemStack>> entry : arena.everyWaveMap.entrySet())
if (wave % entry.getKey() == 0)
private void removeCheatingPlayers() {
List<Player> players = new ArrayList<Player>(arena.getPlayersInArena());
for (Player p : players) {
if (region.contains(p.getLocation())) {
continue;
}
Messenger.tellPlayer(p, "Leaving so soon?");
p.getInventory().clear();
arena.playerLeave(p);
}
}
private void grantRewards(int wave) {
for (Map.Entry<Integer, List<ItemStack>> entry : arena.getEveryWaveEntrySet()) {
if (wave % entry.getKey() == 0) {
addReward(entry.getValue());
if (arena.afterWaveMap.containsKey(wave))
addReward(arena.afterWaveMap.get(wave));
}
private void spawnWave(int wave)
{
Wave w = null;
// Check the first element of the single waves.
if (!singleWaves.isEmpty() && singleWaves.first().matches(wave))
{
w = singleWaves.pollFirst();
}
}
else
{
SortedSet<Wave> matches = getMatchingRecurrentWaves(wave);
w = matches.isEmpty() ? defaultWave : matches.last();
}
// Notify listeners.
for (MobArenaListener listener : plugin.getAM().listeners)
listener.onWave(arena, wave, w.getName(), w.getBranch(), w.getType());
arena.setWave(w);
w.spawn(wave);
}
private void updateStats(int wave)
{
for (ArenaPlayer ap: arena.getArenaPlayerSet())
if (arena.getArenaPlayers().contains(ap.getPlayer()))
ap.getStats().lastWave++;
}
private SortedSet<Wave> getMatchingRecurrentWaves(int wave)
{
TreeSet<Wave> result = new TreeSet<Wave>(WaveUtils.getRecurrentComparator());
for (Wave w : recurrentWaves)
{
if (w.matches(wave))
result.add(w);
List<ItemStack> after = arena.getAfterWaveReward(wave);
if (after != null) {
addReward(after);
}
return result;
}
/*////////////////////////////////////////////////////////////////////
//
// Getters/setters
//
////////////////////////////////////////////////////////////////////*/
public int getWave()
{
return wave;
private void updateStats(int wave) {
for (ArenaPlayer ap : arena.getArenaPlayerSet()) {
if (arena.getPlayersInArena().contains(ap.getPlayer())) {
ap.getStats().inc("lastWave");
}
}
}
public int getTaskId()
{
return taskId;
}
public int getPreviousSize()
{
return previousSize;
}
public int getPlayerCount()
{
/*
* ////////////////////////////////////////////////////////////////////
* //
* // Getters/setters
* //
* ////////////////////////////////////////////////////////////////////
*/
public int getPlayerCount() {
return playerCount;
}
public void setTaskId(int taskId)
{
this.taskId = taskId;
}
public void setPreviousSize(int previousSize)
{
this.previousSize = previousSize;
}
/**
* Rewards all players with an item from the input String.
*/
private void addReward(List<ItemStack> rewards)
{
for (Player p : arena.arenaPlayers)
{
if (arena.log.players.get(p) == null)
continue;
private void addReward(List<ItemStack> rewards) {
for (Player p : arena.getPlayersInArena()) {
ItemStack reward = MAUtils.getRandomReward(rewards);
arena.log.players.get(p).rewards.add(reward);
if (reward == null)
{
MAUtils.tellPlayer(p, "ERROR! Problem with economy rewards. Notify server host!");
MobArena.warning("Could not add null reward. Please check the config-file!");
}
else if (reward.getTypeId() == MobArena.ECONOMY_MONEY_ID)
{
if (plugin.Method != null)
MAUtils.tellPlayer(p, Msg.WAVE_REWARD, plugin.Method.format(reward.getAmount()));
else MobArena.warning("Tried to add money, but no economy plugin detected!");
}
else
{
MAUtils.tellPlayer(p, Msg.WAVE_REWARD, MAUtils.toCamelCase(reward.getType().toString()) + ":" + reward.getAmount(), reward.getType());
}
}
}
/**
* "Detonates" all the Creepers in the monsterSet.
*/
public void detonateCreepers(boolean really)
{
if (!really)
return;
Set<Entity> tmp = new HashSet<Entity>();
for (Entity e : arena.monsters)
{
if (!(e instanceof Creeper) || e.isDead())
continue;
tmp.add(e);
}
rewardManager.addReward(p, reward);
Location loc;
for (Entity e : tmp)
{
if (e == null) continue;
arena.monsters.remove(e);
loc = e.getLocation().getBlock().getRelative(0,2,0).getLocation();
arena.world.createExplosion(loc, 2);
e.remove();
if (reward == null) {
Messenger.tellPlayer(p, "ERROR! Problem with rewards. Notify server host!");
plugin.warning("Could not add null reward. Please check the config-file!");
}
else if (reward.getTypeId() == MobArena.ECONOMY_MONEY_ID) {
if (plugin.giveMoney(p, reward.getAmount())) {
Messenger.tellPlayer(p, Msg.WAVE_REWARD, plugin.economyFormat(reward.getAmount()));
}
else {
plugin.warning("Tried to add money, but no economy plugin detected!");
}
}
else {
Messenger.tellPlayer(p, Msg.WAVE_REWARD, MAUtils.toCamelCase(reward.getType().toString()) + ":" + reward.getAmount(), reward.getType());
}
}
}
/**
* Update the targets of all monsters, if their targets aren't alive.
*/
public void updateTargets()
{
public void updateTargets() {
Creature c;
Entity target;
for (Entity e : arena.monsters)
{
for (Entity e : monsterManager.getMonsters()) {
if (!(e instanceof Creature))
continue;
continue;
// TODO: Remove the try-catch when Bukkit API is fixed.
c = (Creature) e;
try { target = c.getTarget(); } catch (ClassCastException cce) { continue; }
if (target instanceof Player && arena.inArena((Player) target))
try {
target = c.getTarget();
}
catch (ClassCastException cce) {
continue;
c.setTarget(MAUtils.getClosestPlayer(e, arena));
}
if (target instanceof Player && arena.getPlayersInArena().contains((Player) target)) {
continue;
}
c.setTarget(MAUtils.getClosestPlayer(plugin, e, arena));
}
}
}

1316
src/com/garbagemule/MobArena/MAUtils.java
View File

File diff suppressed because it is too large Load Diff

103
src/com/garbagemule/MobArena/Messenger.java Normal file
View File

@ -0,0 +1,103 @@
package com.garbagemule.MobArena;
import java.util.ArrayList;
import java.util.List;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.getspout.spoutapi.SpoutManager;
import org.getspout.spoutapi.player.SpoutPlayer;
import com.garbagemule.MobArena.framework.Arena;
public class Messenger
{
public static boolean tellSpoutPlayer(Player p, Msg msg, String s, Material logo) {
// Grab the SpoutPlayer.
SpoutPlayer sp = MobArena.hasSpout ? SpoutManager.getPlayer(p) : null;
if (msg.hasSpoutMsg() && sp != null && sp.isSpoutCraftEnabled()) {
// Grab the message text.
String text = msg.toSpoutString(s);
// If more than 26 characters, truncate.
if (text.length() > 26)
text = text.substring(0, 26);
// If the logo is null, use an iron sword.
if (logo == null)
logo = msg.getLogo();
// Send the notification.
sp.sendNotification("MobArena", text, logo, (short) 0, 2000);
return true;
}
else {
return tellPlayer(p, msg.toString(s));
}
}
public static boolean tellSpoutPlayer(Player p, Msg msg, Material logo) {
return tellSpoutPlayer(p, msg, null, logo);
}
public static boolean tellSpoutPlayer(Player p, Msg msg, String s) {
return tellSpoutPlayer(p, msg, s, null);
}
public static boolean tellSpoutPlayer(Player p, Msg msg) {
return tellSpoutPlayer(p, msg, null, null);
}
public static boolean tellPlayer(CommandSender p, String msg) {
// If the input sender is null or the string is empty, return.
if (p == null || msg.equals(" "))
return false;
// Otherwise, send the message with the [MobArena] tag.
p.sendMessage(ChatColor.GREEN + "[MobArena] " + ChatColor.WHITE + msg);
return true;
}
public static boolean tellPlayer(CommandSender p, Msg msg, String s, boolean spout, Material logo) {
if (spout && p instanceof Player)
return tellSpoutPlayer((Player) p, msg, s, logo);
return tellPlayer(p, msg.toString(s));
}
public static boolean tellPlayer(CommandSender p, Msg msg, String s, Material logo) {
return tellPlayer(p, msg, s, MobArena.hasSpout, logo);
}
public static boolean tellPlayer(CommandSender p, Msg msg, String s) {
return tellPlayer(p, msg, s, MobArena.hasSpout, null);
}
public static boolean tellPlayer(CommandSender p, Msg msg) {
return tellPlayer(p, msg, null, MobArena.hasSpout, null);
}
public static void tellAll(Arena arena, Msg msg, String s, boolean notifyPlayers) {
List<Player> players = new ArrayList<Player>();
players.addAll(arena.getPlayersInArena());
players.addAll(arena.getPlayersInLobby());
players.addAll(arena.getSpectators());
for (Player p : players)
tellPlayer(p, msg, s);
}
public static void tellAll(Arena arena, Msg msg, String s) {
tellAll(arena, msg, s, false);
}
public static void tellAll(Arena arena, Msg msg, boolean notifyPlayers) {
tellAll(arena, msg, null, notifyPlayers);
}
public static void tellAll(Arena arena, Msg msg) {
tellAll(arena, msg, null, false);
}
}

322
src/com/garbagemule/MobArena/MobArena.java
View File

@ -1,221 +1,279 @@
package com.garbagemule.MobArena;
import java.io.File;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.economy.EconomyResponse;
import net.milkbowl.vault.economy.EconomyResponse.ResponseType;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.Event.Priority;
import org.bukkit.event.block.BlockListener;
import org.bukkit.event.player.PlayerListener;
import org.bukkit.event.entity.EntityListener;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.plugin.PluginManager;
//import org.bukkit.util.config.Configuration;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.ServicesManager;
import org.bukkit.plugin.java.JavaPlugin;
import com.garbagemule.MobArena.ArenaMasterImpl;
import com.garbagemule.MobArena.MAMessages;
import com.garbagemule.MobArena.commands.CommandHandler;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.health.HealthStrategy;
import com.garbagemule.MobArena.health.HealthStrategyHeroes;
import com.garbagemule.MobArena.health.HealthStrategyStandard;
import com.garbagemule.MobArena.listeners.MAGlobalListener;
import com.garbagemule.MobArena.listeners.MagicSpellsListener;
import com.garbagemule.MobArena.spout.Spouty;
import com.garbagemule.MobArena.util.Config;
import com.garbagemule.MobArena.listeners.SpoutScreenListener;
import com.garbagemule.MobArena.util.FileUtils;
import com.garbagemule.register.payment.Method;
import com.garbagemule.register.payment.Methods;
import com.garbagemule.MobArena.util.config.Config;
import com.garbagemule.MobArena.util.config.ConfigUtils;
import com.garbagemule.MobArena.util.inventory.InventoryManager;
/**
* MobArena
* @author garbagemule
*/
public class MobArena extends JavaPlugin implements MobArenaPlugin
public class MobArena extends JavaPlugin
{
//private Configuration config;
private Config config;
private ArenaMaster am;
private ArenaMaster arenaMaster;
// Economy stuff
protected Method Method;
// Inventories from disconnects
private Set<String> inventoriesToRestore;
// Heroes
private boolean hasHeroes;
private HealthStrategy healthStrategy;
// Vault
private Economy economy;
// Spout stuff
public static boolean hasSpout;
// Global variables
public static PluginDescriptionFile desc;
public static File dir, arenaDir;
public static final double MIN_PLAYER_DISTANCE = 15D;
public static final double MIN_PLAYER_DISTANCE_SQUARED = 225D;
public static final int ECONOMY_MONEY_ID = -29;
public static Random random = new Random();
public void onEnable()
{
// Description file and data folders
desc = getDescription();
dir = getDataFolder();
arenaDir = new File(dir, "arenas");
if (!dir.exists()) dir.mkdirs();
if (!arenaDir.exists()) arenaDir.mkdir();
public void onEnable() {
// Create default files and initialize config-file
FileUtils.extractDefaults("config.yml");
loadConfig();
FileUtils.extractDefaults(this, "config.yml");
loadConfigFile();
// Download external libraries if needed.
FileUtils.fetchLibs(config);
FileUtils.fetchLibs(this, config);
// Set up soft dependencies
setupRegister();
setupVault();
setupHeroes();
setupSpout();
setupMagicSpells();
setupStrategies();
// Set up the ArenaMaster and the announcements
am = new ArenaMasterStandard(this);
am.initialize();
// Set up the ArenaMaster
arenaMaster = new ArenaMasterImpl(this);
arenaMaster.initialize();
// Register any inventories to restore.
registerInventories();
// Make sure all the announcements are configured.
MAMessages.init(this);
// Register event listeners
registerListeners();
// Announce enable!
info("v" + desc.getVersion() + " enabled.");
info("v" + this.getDescription().getVersion() + " enabled.");
}
public void onDisable()
{
public void onDisable() {
// Disable Spout features.
hasSpout = false;
// Force all arenas to end.
if (am == null) return;
for (Arena arena : am.arenas)
if (arenaMaster == null) return;
for (Arena arena : arenaMaster.getArenas()) {
arena.forceEnd();
am.arenaMap.clear();
}
arenaMaster.resetArenaMap();
info("disabled.");
}
private void loadConfig()
{
File file = new File(dir, "config.yml");
private void loadConfigFile() {
File dir = this.getDataFolder();
if (!dir.exists()) dir.mkdir();
File file = new File(this.getDataFolder(), "config.yml");
config = new Config(file);
config.load();
updateSettings(config);
config.setHeader(getHeader());
config.save();
}
private void registerListeners()
{
private void registerListeners() {
// Bind the /ma, /mobarena commands to MACommands.
MACommands commandExecutor = new MACommands(this, am);
getCommand("ma").setExecutor(commandExecutor);
getCommand("mobarena").setExecutor(commandExecutor);
CommandHandler handler = new CommandHandler(this);
getCommand("ma").setExecutor(handler);
getCommand("mobarena").setExecutor(handler);
// Create event listeners.
PluginManager pm = getServer().getPluginManager();
PlayerListener playerListener = new MAPlayerListener(this, am);
EntityListener entityListener = new MAEntityListener(am);
BlockListener blockListener = new MABlockListener(am);
PluginManager pm = this.getServer().getPluginManager();
pm.registerEvents(new MAGlobalListener(this, arenaMaster), this);
// Register events.
pm.registerEvent(Event.Type.BLOCK_BREAK, blockListener, Priority.Highest, this);
pm.registerEvent(Event.Type.BLOCK_BURN, blockListener, Priority.Highest, this);
pm.registerEvent(Event.Type.BLOCK_PLACE, blockListener, Priority.Highest, this);
pm.registerEvent(Event.Type.BLOCK_IGNITE, blockListener, Priority.Highest, this);
pm.registerEvent(Event.Type.SIGN_CHANGE, blockListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_INTERACT, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_DROP_ITEM, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_BUCKET_EMPTY, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_TELEPORT, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_QUIT, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_KICK, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_JOIN, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.PLAYER_ANIMATION, playerListener, Priority.Normal, this);
pm.registerEvent(Event.Type.ENTITY_DAMAGE, entityListener, Priority.Low, this); // Must cancel before Heroes
pm.registerEvent(Event.Type.ENTITY_DEATH, entityListener, Priority.Lowest, this); // Lowest because of Tombstone
pm.registerEvent(Event.Type.ENTITY_REGAIN_HEALTH, entityListener, Priority.Normal, this);
pm.registerEvent(Event.Type.ENTITY_EXPLODE, entityListener, Priority.Highest, this);
pm.registerEvent(Event.Type.ENTITY_COMBUST, entityListener, Priority.Normal, this);
pm.registerEvent(Event.Type.ENTITY_TARGET, entityListener, Priority.Normal, this);
pm.registerEvent(Event.Type.ENDERMAN_PICKUP, entityListener, Priority.Normal, this);
pm.registerEvent(Event.Type.ENDERMAN_PLACE, entityListener, Priority.Normal, this);
pm.registerEvent(Event.Type.CREATURE_SPAWN, entityListener, Priority.Highest, this);
pm.registerEvent(Event.Type.PLAYER_COMMAND_PREPROCESS, playerListener, Priority.Monitor, this); // I know Monitor is bad, but other plugins suck! :(
if (hasSpout) {
pm.registerEvents(new SpoutScreenListener(this), this);
}
}
// Permissions stuff
public boolean has(Player p, String s)
{
// If the permission is set, check if player has permission
if (p.isPermissionSet(s))
return p.hasPermission(s);
// Otherwise, only allow commands that aren't admin/setup commands.
return !s.matches("^mobarena\\.setup\\..*$") && !s.matches("^mobarena\\.admin\\..*$");
public boolean has(Player p, String s) {
return p.hasPermission(s);
}
public boolean has(CommandSender sender, String s) {
if (sender instanceof ConsoleCommandSender) {
return true;
}
return has((Player) sender, s);
}
// Console printing
public static void info(String msg) { Bukkit.getServer().getLogger().info("[MobArena] " + msg); }
public static void warning(String msg) { Bukkit.getServer().getLogger().warning("[MobArena] " + msg); }
public static void error(String msg) { Bukkit.getServer().getLogger().severe("[MobArena] " + msg); }
public void info(String msg) { getServer().getLogger().info("[MobArena] " + msg); }
public void warning(String msg) { getServer().getLogger().warning("[MobArena] " + msg); }
public void error(String msg) { getServer().getLogger().severe("[MobArena] " + msg); }
@Override
public void tell(CommandSender sender, String msg) {
if (sender == null || msg.equals("") || msg.equals(" "))
private void setupVault() {
Plugin vaultPlugin = this.getServer().getPluginManager().getPlugin("Vault");
if (vaultPlugin == null) {
warning("Vault was not found. Economy rewards will not work!");
return;
}
sender.sendMessage(ChatColor.GREEN + "[MobArena] " + ChatColor.WHITE + msg);
ServicesManager manager = this.getServer().getServicesManager();
RegisteredServiceProvider<Economy> e = manager.getRegistration(net.milkbowl.vault.economy.Economy.class);
if (e != null) {
economy = e.getProvider();
} else {
warning("Vault found, but no economy plugin detected. Economy rewards will not work!");
}
}
@Override
public void tell(CommandSender sender, Msg msg) {
tell(sender, msg.toString());
private void setupHeroes() {
Plugin heroesPlugin = this.getServer().getPluginManager().getPlugin("Heroes");
if (heroesPlugin == null) return;
hasHeroes = true;
}
private void setupRegister()
{
Methods.setMethod(getServer().getPluginManager());
Method = Methods.getMethod();
if (Method != null)
info("Payment method found (" + Method.getName() + " version: " + Method.getVersion() + ")");
else
info("No payment method found!");
}
private void setupSpout()
{
if (hasSpout) return;
private void setupSpout() {
Plugin spoutPlugin = this.getServer().getPluginManager().getPlugin("Spout");
hasSpout = spoutPlugin != null;
if (!hasSpout) return;
if (spoutPlugin == null) return;
Spouty.registerEvents(this);
hasSpout = true;
}
private void setupMagicSpells()
{
private void setupMagicSpells() {
Plugin spells = this.getServer().getPluginManager().getPlugin("MagicSpells");
if (spells == null) return;
PluginManager pm = getServer().getPluginManager();
pm.registerEvent(Event.Type.CUSTOM_EVENT, new MagicSpellsListener(this), Priority.Normal, this);
this.getServer().getPluginManager().registerEvents(new MagicSpellsListener(this), this);
}
public Config getMAConfig() { return config; }
public ArenaMaster getAM() { return am; } // More convenient.
private void setupStrategies() {
healthStrategy = (hasHeroes ? new HealthStrategyHeroes() : new HealthStrategyStandard());
}
@Override
public ArenaMaster getArenaMaster() { return am; }
public HealthStrategy getHealthStrategy() {
return healthStrategy;
}
private String getHeader()
{
public Config getMAConfig() {
return config;
}
public ArenaMaster getArenaMaster() {
return arenaMaster;
}
private void updateSettings(Config config) {
Set<String> arenas = config.getKeys("arenas");
if (arenas == null) return;
for (String arena : arenas) {
String path = "arenas." + arena + ".settings";
ConfigUtils.replaceAllNodes(this, config, path, "settings.yml");
}
}
private String getHeader() {
String sep = System.getProperty("line.separator");
return "# MobArena v" + desc.getVersion() + " - Config-file" + sep +
"# Read the Wiki for details on how to set up this file: http://goo.gl/F5TTc" + sep +
"# Note: You -must- use spaces instead of tabs!";
return "MobArena v" + this.getDescription().getVersion() + " - Config-file" + sep +
"Read the Wiki for details on how to set up this file: http://goo.gl/F5TTc" + sep +
"Note: You -must- use spaces instead of tabs!\r";
}
private void registerInventories() {
this.inventoriesToRestore = new HashSet<String>();
File dir = new File(getDataFolder(), "inventories");
if (!dir.exists()) {
dir.mkdir();
return;
}
for (File f : dir.listFiles()) {
if (f.getName().endsWith(".inv")) {
inventoriesToRestore.add(f.getName().substring(0, f.getName().indexOf(".")));
}
}
}
public void restoreInventory(Player p) {
if (!inventoriesToRestore.contains(p.getName())) {
return;
}
if (InventoryManager.restoreFromFile(this, p)) {
inventoriesToRestore.remove(p.getName());
}
}
public boolean giveMoney(Player p, int amount) {
if (economy != null) {
EconomyResponse result = economy.depositPlayer(p.getName(), amount);
return (result.type == ResponseType.SUCCESS);
}
return false;
}
public boolean takeMoney(Player p, int amount) {
if (economy != null) {
EconomyResponse result = economy.withdrawPlayer(p.getName(), amount);
return (result.type == ResponseType.SUCCESS);
}
return false;
}
public boolean hasEnough(Player p, double amount) {
if (economy != null) {
return (economy.getBalance(p.getName()) >= amount);
}
return true;
}
public String economyFormat(double amount) {
if (economy != null) {
return economy.format(amount);
}
return null;
}
}

117
src/com/garbagemule/MobArena/MobArenaHandler.java
View File

@ -6,16 +6,18 @@ import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.framework.Arena;
public class MobArenaHandler
{
private MobArena plugin;
/**
* Primary constructor.
* The boolean 'ma' is flagged true, and the field 'plugin' is initalized, if the server is running MobArena.
* The field 'plugin' is initalized, if the server is running MobArena.
*/
public MobArenaHandler()
{
public MobArenaHandler() {
plugin = (MobArena) Bukkit.getServer().getPluginManager().getPlugin("MobArena");
}
@ -32,12 +34,13 @@ public class MobArenaHandler
* @param loc A location.
* @return true, if the Location is inside of any arena region.
*/
public boolean inRegion(Location loc)
{
for (Arena arena : plugin.getAM().arenas)
if (arena.inRegion(loc))
public boolean inRegion(Location loc) {
for (Arena arena : plugin.getArenaMaster().getArenas()) {
if (arena.getRegion().contains(loc)) {
return true;
}
}
return false;
}
@ -47,9 +50,8 @@ public class MobArenaHandler
* @param loc A location
* @return true, if the Location is inside of the arena region.
*/
public boolean inRegion(Arena arena, Location loc)
{
return (arena != null && arena.inRegion(loc));
public boolean inRegion(Arena arena, Location loc) {
return (arena != null && arena.getRegion().contains(loc));
}
/**
@ -58,13 +60,12 @@ public class MobArenaHandler
* @param loc A location
* @return true, if the Location is inside of the arena region.
*/
public boolean inRegion(String arenaName, Location loc)
{
Arena arena = plugin.getAM().getArenaWithName(arenaName);
public boolean inRegion(String arenaName, Location loc) {
Arena arena = plugin.getArenaMaster().getArenaWithName(arenaName);
if (arena == null)
throw new NullPointerException("There is no arena with that name");
return arena.inRegion(loc);
return arena.getRegion().contains(loc);
}
/**
@ -72,8 +73,7 @@ public class MobArenaHandler
* @param loc A location.
* @return true, if the Location is inside of the region of an arena that is currently running.
*/
public boolean inRunningRegion(Location loc)
{
public boolean inRunningRegion(Location loc) {
return inRegion(loc, false, true);
}
@ -82,8 +82,7 @@ public class MobArenaHandler
* @param loc A location.
* @return true, if the Location is inside of the region of an arena that is currently enabled.
*/
public boolean inEnabledRegion(Location loc)
{
public boolean inEnabledRegion(Location loc) {
return inRegion(loc, true, false);
}
@ -94,17 +93,19 @@ public class MobArenaHandler
* @param running if true, the method will check if the arena is running, overrides enabled
* @return true, if the location is inside of the region of an arena that is currently enabled/running, depending on the parameters.
*/
private boolean inRegion(Location loc, boolean enabled, boolean running)
{
private boolean inRegion(Location loc, boolean enabled, boolean running) {
// If the plugin doesn't exist, always return false.
if (plugin.getAM() == null) return false;
if (plugin.getArenaMaster() == null) return false;
// Return true if location is within just one arena's region.
for (Arena arena : plugin.getAM().arenas)
if (arena.inRegion(loc))
if ((running && arena.running) || (enabled && arena.enabled))
for (Arena arena : plugin.getArenaMaster().getArenas()) {
if (arena.getRegion().contains(loc)) {
if ((running && arena.isRunning()) || (enabled && arena.isEnabled())) {
return true;
}
}
}
return false;
}
@ -121,9 +122,8 @@ public class MobArenaHandler
* @param player The player
* @return true, if the player is in an arena
*/
public boolean isPlayerInArena(Player player)
{
return (plugin.getAM().getArenaWithPlayer(player) != null);
public boolean isPlayerInArena(Player player) {
return (plugin.getArenaMaster().getArenaWithPlayer(player) != null);
}
/**
@ -131,9 +131,8 @@ public class MobArenaHandler
* @param playerName The name of the player
* @return true, if the player is in an arena
*/
public boolean isPlayerInArena(String playerName)
{
return (plugin.getAM().getArenaWithPlayer(playerName) != null);
public boolean isPlayerInArena(String playerName) {
return (plugin.getArenaMaster().getArenaWithPlayer(playerName) != null);
}
/**
@ -141,12 +140,11 @@ public class MobArenaHandler
* @param player The player
* @return The class name of the player if the player is in the arena, null otherwise
*/
public String getPlayerClass(Player player)
{
Arena arena = plugin.getAM().getArenaWithPlayer(player);
public String getPlayerClass(Player player) {
Arena arena = plugin.getArenaMaster().getArenaWithPlayer(player);
if (arena == null) return null;
return arena.classMap.get(player);
return getPlayerClass(arena, player);
}
/**
@ -156,9 +154,14 @@ public class MobArenaHandler
* @param player The player to look up
* @return The class name of the player, if the player is in the arena, null otherwise
*/
public String getPlayerClass(Arena arena, Player player)
{
return arena.classMap.get(player);
public String getPlayerClass(Arena arena, Player player) {
ArenaPlayer ap = arena.getArenaPlayer(player);
if (ap == null) return null;
ArenaClass ac = ap.getArenaClass();
if (ac == null) return null;
return ac.getName();
}
/**
@ -166,9 +169,8 @@ public class MobArenaHandler
* @param entity The monster entity
* @return true, if the monster is in an arena
*/
public boolean isMonsterInArena(LivingEntity entity)
{
return plugin.getAM().getArenaWithMonster(entity) != null;
public boolean isMonsterInArena(LivingEntity entity) {
return plugin.getArenaMaster().getArenaWithMonster(entity) != null;
}
/**
@ -176,9 +178,8 @@ public class MobArenaHandler
* @param wolf The pet wolf
* @return true, if the pet is in an arena
*/
public boolean isPetInArena(LivingEntity wolf)
{
return plugin.getAM().getArenaWithPet(wolf) != null;
public boolean isPetInArena(LivingEntity wolf) {
return plugin.getArenaMaster().getArenaWithPet(wolf) != null;
}
@ -194,9 +195,8 @@ public class MobArenaHandler
* @param loc A location
* @return an Arena object, or null
*/
public Arena getArenaAtLocation(Location loc)
{
return plugin.getAM().getArenaAtLocation(loc);
public Arena getArenaAtLocation(Location loc) {
return plugin.getArenaMaster().getArenaAtLocation(loc);
}
/**
@ -204,9 +204,8 @@ public class MobArenaHandler
* @param p A player
* @return an Arena object, or null
*/
public Arena getArenaWithPlayer(Player p)
{
return plugin.getAM().getArenaWithPlayer(p);
public Arena getArenaWithPlayer(Player p) {
return plugin.getArenaMaster().getArenaWithPlayer(p);
}
/**
@ -214,9 +213,8 @@ public class MobArenaHandler
* @param wolf A pet wolf
* @return an Arena object, or null
*/
public Arena getArenaWithPet(Entity wolf)
{
return plugin.getAM().getArenaWithPet(wolf);
public Arena getArenaWithPet(Entity wolf) {
return plugin.getArenaMaster().getArenaWithPet(wolf);
}
/**
@ -224,8 +222,7 @@ public class MobArenaHandler
* @param monster A monster
* @return an Arena object, or null
*/
public Arena getArenaWithMonster(Entity monster)
{
return plugin.getAM().getArenaWithMonster(monster);
public Arena getArenaWithMonster(Entity monster) {
return plugin.getArenaMaster().getArenaWithMonster(monster);
}
}

25
src/com/garbagemule/MobArena/MobArenaListener.java
View File

@ -1,25 +0,0 @@
package com.garbagemule.MobArena;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.waves.Wave.WaveBranch;
import com.garbagemule.MobArena.waves.Wave.WaveType;
public abstract class MobArenaListener
{
protected MobArena plugin;
public MobArenaListener()
{
plugin = (MobArena) Bukkit.getServer().getPluginManager().getPlugin("MobArena");
plugin.getAM().listeners.add(this);
}
public void onArenaStart(Arena arena) {}
public void onArenaEnd(Arena arena) {}
public void onWave(Arena arena, int waveNumber, String waveName, WaveBranch waveBranch, WaveType waveType) {}
public void onPlayerJoin(Arena arena, Player p) {}
public void onPlayerLeave(Arena arena, Player p) {}
public void onPlayerDeath(Arena arena, Player p) {}
}

36
src/com/garbagemule/MobArena/MobArenaPlugin.java
View File

@ -1,36 +0,0 @@
package com.garbagemule.MobArena;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.util.Config;
public interface MobArenaPlugin
{
/**
* Get the Config object associated with this MobArena instance.
* @return the Config object used by MobArena
*/
public Config getMAConfig();
/**
* Get the ArenaMaster used by this instance of MobArena.
* @return the ArenaMaster object
*/
public ArenaMaster getArenaMaster();
/**
* Send a message to a player or the console.
* The message is prefixed with [MobArena].
* @param recipient the player or console to send the message to
* @param msg the message to send
*/
public void tell(CommandSender recipient, String msg);
/**
* Send a predefined announcement to a player or the console.
* Convenience method: the above method is called with Msg.toString()
* @param recipient the player or console to send the message to
* @param msg the message to send
*/
public void tell(CommandSender recipient, Msg msg);
}

130
src/com/garbagemule/MobArena/MonsterManager.java Normal file
View File

@ -0,0 +1,130 @@
package com.garbagemule.MobArena;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Wolf;
import org.bukkit.inventory.ItemStack;
import com.garbagemule.MobArena.waves.MABoss;
public class MonsterManager
{
private Set<LivingEntity> monsters, sheep;
private Set<Wolf> pets;
private Map<LivingEntity,MABoss> bosses;
private Map<LivingEntity,List<ItemStack>> suppliers;
public MonsterManager() {
this.monsters = new HashSet<LivingEntity>();
this.sheep = new HashSet<LivingEntity>();
this.pets = new HashSet<Wolf>();
this.bosses = new HashMap<LivingEntity,MABoss>();
this.suppliers = new HashMap<LivingEntity,List<ItemStack>>();
}
public void reset() {
monsters.clear();
sheep.clear();
pets.clear();
bosses.clear();
suppliers.clear();
}
public void clear() {
removeAll(monsters);
removeAll(sheep);
removeAll(pets);
removeAll(bosses.keySet());
removeAll(suppliers.keySet());
reset();
}
private void removeAll(Collection<? extends LivingEntity> collection) {
for (LivingEntity e : collection) {
if (e != null) {
e.remove();
}
}
}
public Set<LivingEntity> getMonsters() {
return monsters;
}
public void addMonster(LivingEntity e) {
monsters.add(e);
}
public boolean removeMonster(Entity e) {
return monsters.remove(e);
}
public Set<LivingEntity> getExplodingSheep() {
return sheep;
}
public void addExplodingSheep(LivingEntity e) {
sheep.add(e);
}
public boolean removeExplodingSheep(LivingEntity e) {
return sheep.remove(e);
}
public Set<Wolf> getPets() {
return pets;
}
public void addPet(Wolf w) {
pets.add(w);
}
public boolean hasPet(Entity e) {
return pets.contains(e);
}
public void removePets(Player p) {
for (Wolf w : pets) {
if (w == null || !(w.getOwner() instanceof Player) || !((Player) w.getOwner()).getName().equals(p.getName()))
continue;
w.setOwner(null);
w.remove();
}
}
public void addSupplier(LivingEntity e, List<ItemStack> drops) {
suppliers.put(e, drops);
}
public List<ItemStack> getLoot(Entity e) {
return suppliers.get(e);
}
public MABoss addBoss(LivingEntity e, int maxHealth) {
MABoss b = new MABoss(e, maxHealth);
bosses.put(e, b);
return b;
}
public MABoss removeBoss(LivingEntity e) {
return bosses.remove(e);
}
public MABoss getBoss(LivingEntity e) {
return bosses.get(e);
}
public Set<LivingEntity> getBossMonsters() {
return bosses.keySet();
}
}

6
src/com/garbagemule/MobArena/Msg.java
View File

@ -53,6 +53,8 @@ public enum Msg
WAVE_DEFAULT("Wave #%!", "Wave #%!", Material.YELLOW_FLOWER),
WAVE_SPECIAL("Wave #%! [SPECIAL]", "Wave #%! [SPECIAL]", Material.RED_ROSE),
WAVE_SWARM("Wave #%! [SWARM]", "Wave #%! [SWARM]", Material.LONG_GRASS),
WAVE_SUPPLY("Wave #%! [SUPPLY]", "Wave #%! [SUPPLY]", Material.BREAD),
WAVE_UPGRADE("Wave #%! [UPGRADE]", "Wave #%! [UPGRADE]", Material.DIAMOND),
WAVE_BOSS("Wave #%! [BOSS]", "Wave #%! [BOSS]", Material.FIRE),
WAVE_BOSS_ABILITY("Boss used ability: %!", "Boss: %", Material.FIRE),
WAVE_BOSS_LOW_HEALTH("Boss is almost dead!", "Boss almost dead!", Material.FIRE),
@ -61,6 +63,10 @@ public enum Msg
MISC_LIST_ARENAS("Available arenas: %"),
MISC_COMMAND_NOT_ALLOWED("You can't use that command in the arena!"),
MISC_NO_ACCESS("You don't have access to this command."),
MISC_NOT_FROM_CONSOLE("You can't use this command from the console."),
MISC_HELP("For a list of commands, type /ma help"),
MISC_MULTIPLE_MATCHES("Did you mean one of these commands?"),
MISC_NO_MATCHES("Command not found. Type /ma help"),
MISC_NONE("<none>");
private String msg, spoutMsg;

108
src/com/garbagemule/MobArena/PlayerData.java Normal file
View File

@ -0,0 +1,108 @@
package com.garbagemule.MobArena;
import java.util.Collection;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect;
public class PlayerData
{
private Player player;
private int health, food, level;
private float exp;
private GameMode mode = null;
private Location entry = null;
private Collection<PotionEffect> potions;
public PlayerData(Player player) {
this.player = player;
this.mode = player.getGameMode();
this.entry = player.getLocation();
this.potions = player.getActivePotionEffects();
update();
}
/**
* Updates the information that is restored, when a player
* dies in the arena, that is, health, food level, and
* experience. Used when a player re-joins an arena while
* already being a spectator.
*/
public void update() {
this.health = player.getHealth();
this.food = player.getFoodLevel();
this.level = player.getLevel();
this.exp = player.getExp();
}
/**
* Restores health, food level, and experience as per the
* currently stored values of this object. Used when a
* player leaves the arena.
*/
public void restoreData() {
player.setFoodLevel(food);
player.setLevel(level);
player.setExp(exp);
}
public Player getPlayer() {
return player;
}
public int health() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int food() {
return food;
}
public void setFood(int food) {
this.food = food;
}
public int level() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public float exp() {
return exp;
}
public void setExp(int exp) {
this.exp = exp;
}
public GameMode getMode() {
return mode;
}
public Collection<PotionEffect> getPotionEffects() {
return potions;
}
public void setMode(GameMode mode) {
this.mode = mode;
}
public Location entry() {
return entry;
}
public void setEntry(Location entry) {
this.entry = entry;
}
}

63
src/com/garbagemule/MobArena/RewardManager.java Normal file
View File

@ -0,0 +1,63 @@
package com.garbagemule.MobArena;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import com.garbagemule.MobArena.framework.Arena;
public class RewardManager
{
private MobArena plugin;
@SuppressWarnings("unused")
private Arena arena;
private Map<Player,List<ItemStack>> players;
private Set<Player> rewarded;
public RewardManager(Arena arena) {
this.plugin = arena.getPlugin();
this.arena = arena;
this.players = new HashMap<Player,List<ItemStack>>();
this.rewarded = new HashSet<Player>();
}
public void reset() {
players.clear();
rewarded.clear();
}
public void addReward(Player p, ItemStack stack) {
if (!players.containsKey(p)) {
players.put(p, new ArrayList<ItemStack>());
}
players.get(p).add(stack);
}
public void grantRewards(Player p) {
if (rewarded.contains(p)) return;
List<ItemStack> rewards = players.get(p);
if (rewards == null) return;
for (ItemStack stack : rewards) {
if (stack == null) {
continue;
}
if (stack.getTypeId() == MobArena.ECONOMY_MONEY_ID) {
plugin.giveMoney(p, stack.getAmount());
continue;
}
p.getInventory().addItem(stack);
}
rewarded.add(p);
}
}

20
src/com/garbagemule/MobArena/commands/Command.java Normal file
View File

@ -0,0 +1,20 @@
package com.garbagemule.MobArena.commands;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.framework.ArenaMaster;
public interface Command
{
/**
* Execute the command using the given arguments.
* If any arguments are provided, the first argument is -NOT- the
* same as the command name, i.e. the CommandHandler must strip the
* array of this element.
* @param am an ArenaMaster instance
* @param sender the sender
* @param args array of arguments
* @return true, if the command was successful
*/
public boolean execute(ArenaMaster am, CommandSender sender, String... args);
}

256
src/com/garbagemule/MobArena/commands/CommandHandler.java
View File

@ -1,123 +1,217 @@
package com.garbagemule.MobArena.commands;
import java.io.File;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.bukkit.command.*;
import org.bukkit.entity.Player;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.util.classparsing.*;
import com.garbagemule.MobArena.commands.user.*;
import com.garbagemule.MobArena.commands.admin.*;
import com.garbagemule.MobArena.commands.setup.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
public class CommandHandler implements CommandExecutor
{
/* COMMAND_PATH is an incomplete package-name for all commands in MobArena,
* hence the trailing dot, and the COMMAND_TYPES array contains all the
* different types of commands (the sub-folders). Both are used in the
* loadCommands() method. */
private static final String COMMAND_PATH = "com.garbagemule.MobArena.commands.";
private static final String[] COMMAND_TYPES = new String[]{"user", "admin", "setup"};
private MobArena plugin;
private ArenaMaster am;
private MobArenaPlugin plugin;
private Map<String,MACommand> commands;
private Map<String,Command> commands;
public CommandHandler(MobArenaPlugin plugin) {
this.plugin = plugin;
this.commands = new HashMap<String,MACommand>();
loadCommands();
public CommandHandler(MobArena plugin) {
this.plugin = plugin;
this.am = plugin.getArenaMaster();
registerCommands();
}
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
if (args.length == 0) {
plugin.tell(sender, Msg.MISC_NONE);
public boolean onCommand(CommandSender sender, org.bukkit.command.Command bcmd, String label, String[] args) {
// Grab the base and arguments.
String base = (args.length > 0 ? args[0] : "");
String last = (args.length > 0 ? args[args.length - 1] : "");
// If there's no base argument, show a helpful message.
if (base.equals("")) {
Messenger.tellPlayer(sender, Msg.MISC_HELP);
return true;
}
// Grab the command from the map, and if null, didn't work.
MACommand command = commands.get(args[0]);
if (command == null) {
System.out.println("Command '" + label + "' not recognized");
// The help command is a little special
if (base.equals("?") || base.equals("help")) {
showHelp(sender);
return true;
}
// Cast if sender is a Player, null otherwise.
Player p = (sender instanceof Player) ? (Player) sender : null;
// Get all commands that match the base.
List<Command> matches = getMatchingCommands(base);
// If null, must be console.
if (p == null) {
if (!command.executeFromConsole(plugin, sender, args)) {
sender.sendMessage("Can't use that command from the console.");
// If there's more than one match, display them.
if (matches.size() > 1) {
Messenger.tellPlayer(sender, Msg.MISC_MULTIPLE_MATCHES);
for (Command cmd : matches) {
showUsage(cmd, sender);
}
return true;
}
// Otherwise, check permissions
if (!p.hasPermission(command.getPermission())) {
sender.sendMessage("No permission");
// If there are no matches at all, notify.
if (matches.size() == 0) {
Messenger.tellPlayer(sender, Msg.MISC_NO_MATCHES);
return true;
}
// Execute!
command.execute(plugin, p, trimFirstArg(args));
// Grab the only match.
Command command = matches.get(0);
CommandInfo info = command.getClass().getAnnotation(CommandInfo.class);
// First check if the sender has permission.
if (!plugin.has(sender, info.permission())) {
Messenger.tellPlayer(sender, Msg.MISC_NO_ACCESS);
return true;
}
// Check if the last argument is a ?, in which case, display usage and description
if (last.equals("?") || last.equals("help")) {
showUsage(command, sender);
return true;
}
// Otherwise, execute the command!
String[] params = trimFirstArg(args);
command.execute(am, sender, params);
return true;
}
/**
* Since Java doesn't support pointer arithmetic, this method
* attempts to remove the first element of a String[] object
* by creating a new array of the same size -1 and copying all
* the elements over.
* @param args a String[] to trim
* @return a String[] with the same elements except for the very first
* Get all commands that match a given string.
* @param arg the given string
* @return a list of commands whose patterns match the given string
*/
private String[] trimFirstArg(String[] args) {
String[] result = new String[args.length - 1];
for (int i = 0; i < result.length; i++) {
result[i] = args[i+1];
private List<Command> getMatchingCommands(String arg) {
List<Command> result = new ArrayList<Command>();
// Grab the commands that match the argument.
for (Entry<String,Command> entry : commands.entrySet()) {
if (arg.matches(entry.getKey())) {
result.add(entry.getValue());
}
}
return result;
}
/**
* Load all of the MobArena commands from either the jar or the bin
* folder into the commands-map. Each one of a commands' names/aliases
* is added to the map, such that both "/ma join" and "/ma j" work, for
* instance.
* Show the usage and description messages of a command to a player.
* The usage will only be shown, if the player has permission for the command.
* @param cmd a Command
* @param sender a CommandSender
*/
private void loadCommands() {
// Prepare a strategy for the class parser.
ClassIterationStrategy strategy = null;
File f = new File("plugins" + File.separator + "MobArena.jar");
try {
// If jar exists, use it - otherwise, use bin.
strategy = (f.exists()) ? new JarClassIterationStrategy(f) :
new DirClassIterationStrategy(new File("bin"));
private void showUsage(Command cmd, CommandSender sender) {
CommandInfo info = cmd.getClass().getAnnotation(CommandInfo.class);
if (!plugin.has(sender, info.permission())) return;
// Create a new ClassParser with the given strategy.
ClassParser parser = new ClassParser(strategy);
// Iterate through all three folders, user/admin/setup
for (String type : COMMAND_TYPES) {
Collection<Class<?>> classes = parser.getClasses(COMMAND_PATH + type);
for (Class<?> c : classes) {
// Make sure the class is indeed an instance of MACommand
Object obj = c.newInstance();
if (!(obj instanceof MACommand))
continue;
// Then cast, and add for each command name/alias
MACommand command = (MACommand) obj;
for (String name : command.getNames()) {
commands.put(name, command);
}
}
}
} catch (Exception e) {
Messenger.tellPlayer(sender, info.usage() + " " + ChatColor.YELLOW + info.desc());
}
/**
* Remove the first argument of a string. This is because the very first
* element of the arguments array will be the command itself.
* @param args an array of length n
* @return the same array minus the first element, and thus of length n-1
*/
private String[] trimFirstArg(String[] args) {
return Arrays.copyOfRange(args, 1, args.length);
}
/**
* List all the available MobArena commands for the CommandSender.
* @param sender a player or the console
*/
private void showHelp(CommandSender sender) {
Messenger.tellPlayer(sender, "Available MobArena commands:");
for (Command cmd : commands.values()) {
showUsage(cmd, sender);
}
}
/**
* Register all the commands directly.
* This could also be done with a somewhat dirty classloader/resource reader
* method, but this is neater, albeit more manual work.
*/
private void registerCommands() {
commands = new HashMap<String,Command>();
// mobarena.use
register(ArenaListCommand.class);
register(JoinCommand.class);
register(LeaveCommand.class);
register(NotReadyCommand.class);
register(SpecCommand.class);
register(PlayerListCommand.class);
// mobarena.admin
register(DisableCommand.class);
register(EnableCommand.class);
register(ForceCommand.class);
register(KickCommand.class);
register(RestoreCommand.class);
// mobarena.setup
register(AddArenaCommand.class);
register(AddClassPermCommand.class);
register(AddContainerCommand.class);
register(AddSpawnpointCommand.class);
register(ArenaCommand.class);
register(CheckDataCommand.class);
register(ConfigCommand.class);
register(ContainersCommand.class);
register(EditArenaCommand.class);
register(ExpandLobbyRegionCommand.class);
register(ExpandRegionCommand.class);
register(ListClassesCommand.class);
register(ListClassPermsCommand.class);
register(ProtectCommand.class);
register(RemoveArenaCommand.class);
register(RemoveClassCommand.class);
register(RemoveClassPermCommand.class);
register(RemoveContainerCommand.class);
register(RemoveSpawnpointCommand.class);
register(SetArenaCommand.class);
register(SetClassCommand.class);
register(SetLobbyRegionCommand.class);
register(SetRegionCommand.class);
register(SetWarpCommand.class);
register(ShowRegionCommand.class);
register(SpawnpointsCommand.class);
register(AutoGenerateCommand.class);
register(AutoDegenerateCommand.class);
}
/**
* Register a single command.
* The Command's CommandInfo annotation is queried to find its pattern
* string, which is used to map the commands.
* @param c a Command
*/
private void register(Class<? extends Command> c) {
CommandInfo info = c.getAnnotation(CommandInfo.class);
if (info == null) return;
try {
commands.put(info.pattern(), c.newInstance());
}
catch (Exception e) {
e.printStackTrace();
}
}
}
}

33
src/com/garbagemule/MobArena/commands/CommandInfo.java Normal file
View File

@ -0,0 +1,33 @@
package com.garbagemule.MobArena.commands;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface CommandInfo
{
/**
* The actual name of the command. Not really used anywhere.
*/
public String name();
/**
* A regex pattern that allows minor oddities and alternatives to the command name.
*/
public String pattern();
/**
* The usage message, i.e. how the command should be used.
*/
public String usage();
/**
* A description of what the command does.
*/
public String desc();
/**
* The permission required to execute this command.
*/
public String permission();
}

31
src/com/garbagemule/MobArena/commands/Commands.java Normal file
View File

@ -0,0 +1,31 @@
package com.garbagemule.MobArena.commands;
import java.util.List;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.Messenger;
import com.garbagemule.MobArena.Msg;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
public class Commands
{
public static boolean isPlayer(CommandSender sender) {
return (sender instanceof Player);
}
public static boolean sanityChecks(Player p, ArenaMaster am, Arena arena, String arg1, List<Arena> arenas) {
if (arenas.size() > 1 && arg1.isEmpty())
Messenger.tellPlayer(p, Msg.JOIN_ARG_NEEDED);
else if (arena == null)
Messenger.tellPlayer(p, Msg.ARENA_DOES_NOT_EXIST);
else if (am.getArenaWithPlayer(p) != null && !arena.equals(am.getArenaWithPlayer(p)))
Messenger.tellPlayer(p, Msg.JOIN_IN_OTHER_ARENA);
else
return true;
return false;
}
}

40
src/com/garbagemule/MobArena/commands/MACommand.java
View File

@ -1,40 +0,0 @@
package com.garbagemule.MobArena.commands;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.MobArenaPlugin;
public interface MACommand
{
/**
* Get an array of names/aliases for this command.
* Every command must have at least one name/alias to work.
* @return a String[] of names/aliases
*/
public String[] getNames();
/**
* Get the permission required to execute this command.
* If there is no permission required, the method returns
* the empty string.
* @return a permission or null
*/
public String getPermission();
/**
* Execute the implementing command with the input Player as the executor.
* @param sender The Player executing the command
* @param args A list of arguments
* @return true, if the command was executed successfully, false otherwise
*/
public boolean execute(MobArenaPlugin plugin, Player sender, String... args);
/**
* Execute the implementing command with the console as the executor.
* @param sender The console executing the command
* @param args A list of arguments
* @return true, if the command was executed successfully, false otherwise
*/
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args);
}

55
src/com/garbagemule/MobArena/commands/admin/DisableCommand.java Normal file
View File

@ -0,0 +1,55 @@
package com.garbagemule.MobArena.commands.admin;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "disable",
pattern = "disable|off",
usage = "/ma disable (<arena>|all)",
desc = "disable MobArena or individual arenas",
permission = "mobarena.admin.enable"
)
public class DisableCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
if (arg1.equals("all")) {
for (Arena arena : am.getArenas()) {
disable(arena, sender);
}
return true;
}
if (!arg1.equals("")) {
Arena arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
disable(arena, sender);
return true;
}
am.setEnabled(true);
am.saveConfig();
Messenger.tellPlayer(sender, "MobArena " + ChatColor.RED + "disabled");
return true;
}
private void disable(Arena arena, CommandSender sender) {
arena.setEnabled(false);
arena.getSettings().getParent().save();
Messenger.tellPlayer(sender, "Arena '" + arena.configName() + "' " + ChatColor.RED + "disabled");
}
}

57
src/com/garbagemule/MobArena/commands/admin/EnableCommand.java
View File

@ -1,30 +1,55 @@
package com.garbagemule.MobArena.commands.admin;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
public class EnableCommand implements MACommand
@CommandInfo(
name = "enable",
pattern = "enable|on",
usage = "/ma enable",
desc = "enable MobArena or individual arenas",
permission = "mobarena.admin.enable"
)
public class EnableCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "enable" };
}
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
if (arg1.equals("all")) {
for (Arena arena : am.getArenas()) {
enable(arena, sender);
}
return true;
}
if (!arg1.equals("")) {
Arena arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
@Override
public String getPermission() {
return "mobarena.admin.enable";
enable(arena, sender);
return true;
}
am.setEnabled(true);
am.saveConfig();
Messenger.tellPlayer(sender, "MobArena " + ChatColor.GREEN + "enabled");
return true;
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
return false;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
private void enable(Arena arena, CommandSender sender) {
arena.setEnabled(true);
arena.getSettings().getParent().save();
Messenger.tellPlayer(sender, "Arena '" + arena.configName() + "' " + ChatColor.GREEN + "enabled");
}
}

90
src/com/garbagemule/MobArena/commands/admin/ForceCommand.java Normal file
View File

@ -0,0 +1,90 @@
package com.garbagemule.MobArena.commands.admin;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "force",
pattern = "force",
usage = "/ma force start|end (<arena>)",
desc = "force start or end an arena",
permission = "mobarena.admin.force"
)
public class ForceCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
if (arg1.equals("end")) {
// With no arguments, end all.
if (arg2.equals("")) {
for (Arena arena : am.getArenas()) {
arena.forceEnd();
}
Messenger.tellPlayer(sender, Msg.FORCE_END_ENDED);
am.resetArenaMap();
return true;
}
// Otherwise, grab the arena in question.
Arena arena = am.getArenaWithName(arg2);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
if (arena.getAllPlayers().isEmpty()) {
Messenger.tellPlayer(sender, Msg.FORCE_END_EMPTY);
return false;
}
// And end it!
arena.forceEnd();
Messenger.tellPlayer(sender, Msg.FORCE_END_ENDED);
return true;
}
if (arg1.equals("start")) {
// Require argument.
if (arg2.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma force start <arena>");
return false;
}
// Grab the arena.
Arena arena = am.getArenaWithName(arg2);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
if (arena.isRunning()) {
Messenger.tellPlayer(sender, Msg.FORCE_START_RUNNING);
return false;
}
if (arena.getReadyPlayersInLobby().isEmpty()) {
Messenger.tellPlayer(sender, Msg.FORCE_START_NOT_READY);
return false;
}
// And start it!
arena.forceStart();
Messenger.tellPlayer(sender, Msg.FORCE_START_STARTED);
return true;
}
Messenger.tellPlayer(sender, "Usage: /ma force start|end (<arena name>)");
return true;
}
}

47
src/com/garbagemule/MobArena/commands/admin/KickCommand.java Normal file
View File

@ -0,0 +1,47 @@
package com.garbagemule.MobArena.commands.admin;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "kick",
pattern = "kick|kcik",
usage = "/ma kick <player>",
desc = "kick a player from an arena",
permission = "mobarena.admin.kick"
)
public class KickCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma kick <player>");
return false;
}
Arena arena = am.getArenaWithPlayer(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, "That player is not in an arena.");
return false;
}
// Grab the Player object.
Player bp = am.getPlugin().getServer().getPlayer(arg1);
// Force leave.
arena.playerLeave(bp);
Messenger.tellPlayer(sender, "Player '" + arg1 + "' was kicked from arena '" + arena.configName() + "'.");
Messenger.tellPlayer(bp, "You were kicked by " + sender.getName() + ".");
return true;
}
}

43
src/com/garbagemule/MobArena/commands/admin/RestoreCommand.java Normal file
View File

@ -0,0 +1,43 @@
package com.garbagemule.MobArena.commands.admin;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.inventory.InventoryManager;
@CommandInfo(
name = "restore",
pattern = "restore",
usage = "/ma restore <player>",
desc = "restore a player's inventory",
permission = "mobarena.admin.restore"
)
public class RestoreCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma restore <player>");
return false;
}
if (am.getArenaWithPlayer(arg1) != null) {
Messenger.tellPlayer(sender, "Player is currently in an arena.");
return false;
}
if (InventoryManager.restoreFromFile(am.getPlugin(), am.getPlugin().getServer().getPlayer(arg1))) {
Messenger.tellPlayer(sender, "Restored " + arg1 + "'s inventory!");
} else {
Messenger.tellPlayer(sender, "Failed to restore " + arg1 + "'s inventory.");
}
return true;
}
}

51
src/com/garbagemule/MobArena/commands/setup/AddArenaCommand.java Normal file
View File

@ -0,0 +1,51 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "addarena",
pattern = "(add|new)arena",
usage = "/ma addarena <arena>",
desc = "add a new arena",
permission = "mobarena.setup.addarena"
)
public class AddArenaCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma addarena <arena>");
return true;
}
Arena arena = am.getArenaWithName(arg1);
if (arena != null) {
Messenger.tellPlayer(sender, "An arena with that name already exists.");
return true;
}
arena = am.createArenaNode(arg1, p.getWorld());
am.setSelectedArena(arena);
Messenger.tellPlayer(sender, "New arena with name '" + arg1 + "' created!");
return true;
}
}

47
src/com/garbagemule/MobArena/commands/setup/AddClassPermCommand.java Normal file
View File

@ -0,0 +1,47 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.TextUtils;
@CommandInfo(
name = "addclassperm",
pattern = "add(class)?perm(.*)",
usage = "/ma addclassperm <classname> <permission>",
desc = "add a per-class permission",
permission = "mobarena.setup.classes"
)
public class AddClassPermCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
if (arg1.equals("") || arg2.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma addclassperm <classname> <permission>");
return false;
}
// Grab the arena class
ArenaClass arenaClass = am.getClasses().get(arg1);
if (arenaClass == null) {
Messenger.tellPlayer(sender, "The class '" + TextUtils.camelCase(arg1) + "' does not exist.");
return false;
}
// Try to add the permission.
if (am.addClassPermission(arg1, arg2)) {
Messenger.tellPlayer(sender, "Added permission '" + arg2 + "' to class '" + TextUtils.camelCase(arg1) + "'.");
return true;
}
// If it wasn't added, notify.
Messenger.tellPlayer(sender, "Permission '" + arg2 + "' was NOT added to class '" + TextUtils.camelCase(arg1) + "'.");
return false;
}
}

47
src/com/garbagemule/MobArena/commands/setup/AddContainerCommand.java Normal file
View File

@ -0,0 +1,47 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.block.ContainerBlock;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "addcontainer",
pattern = "add(chest|container)",
usage = "/ma addcontainer <point name>",
desc = "add a new container for the selected arena",
permission = "mobarena.setup.containers"
)
public class AddContainerCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
if (!arg1.matches("^[a-zA-Z][a-zA-Z0-9]*$")) {
Messenger.tellPlayer(sender, "Usage: /ma addcontainer <point name>");
return false;
}
if (!(p.getTargetBlock(null, 50).getState() instanceof ContainerBlock)) {
Messenger.tellPlayer(sender, "You must look at container.");
return false;
}
am.getSelectedArena().getRegion().addChest(arg1, p.getTargetBlock(null, 50).getLocation());
Messenger.tellPlayer(sender, "Container '" + arg1 + "' added for arena \"" + am.getSelectedArena().configName() + "\"");
return true;
}
}

41
src/com/garbagemule/MobArena/commands/setup/AddSpawnpointCommand.java Normal file
View File

@ -0,0 +1,41 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "addspawn",
pattern = "addspawn(point)?",
usage = "/ma addspawn <point name>",
desc = "add a new spawnpoint for the selected arena",
permission = "mobarena.setup.spawnpoints"
)
public class AddSpawnpointCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
if (!arg1.matches("^[a-zA-Z][a-zA-Z0-9]*$")) {
Messenger.tellPlayer(sender, "Usage: /ma addspawn <point name>");
return true;
}
am.getSelectedArena().getRegion().addSpawn(arg1, p.getLocation());
Messenger.tellPlayer(sender, "Spawnpoint " + arg1 + " added for arena \"" + am.getSelectedArena().configName() + "\"");
return true;
}
}

37
src/com/garbagemule/MobArena/commands/setup/ArenaCommand.java Normal file
View File

@ -0,0 +1,37 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "arena",
pattern = "arena",
usage = "/ma arena",
desc = "list the currently selected arena",
permission = "mobarena.setup.arena"
)
public class ArenaCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
Messenger.tellPlayer(sender, "Currently selected arena: " + ChatColor.GREEN + am.getSelectedArena().configName());
StringBuffer buffy = new StringBuffer();
if (am.getArenas().size() > 1) {
for (Arena arena : am.getArenas()) {
if (!arena.equals(am.getSelectedArena())) {
buffy.append(arena.configName() + " ");
}
}
}
else buffy.append(Msg.MISC_NONE);
Messenger.tellPlayer(sender, "Other arenas: " + buffy.toString());
return true;
}
}

50
src/com/garbagemule/MobArena/commands/setup/AutoDegenerateCommand.java Normal file
View File

@ -0,0 +1,50 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "autodegenerate",
pattern = "auto(\\-)?degenerate",
usage = "/ma autodegenerate <arena>",
desc = "autodegenerate an existing arena",
permission = "mobarena.setup.autodegenerate"
)
public class AutoDegenerateCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the arguments, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma autodegenerate <arena>");
return true;
}
if (am.getArenas().size() < 2) {
Messenger.tellPlayer(sender, "At least one arena must exist!");
return true;
}
// Check if arena exists.
Arena arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return true;
}
if (!MAUtils.undoItHippieMonster(arg1, am.getPlugin(), true)) {
Messenger.tellPlayer(sender, "Could not degenerate arena.");
return true;
}
Messenger.tellPlayer(sender, "Arena with name '" + arg1 + "' degenerated.");
return true;
}
}

54
src/com/garbagemule/MobArena/commands/setup/AutoGenerateCommand.java Normal file
View File

@ -0,0 +1,54 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "autogenerate",
pattern = "auto(\\-)?generate",
usage = "/ma autogenerate <arena>",
desc = "autogenerate a new arena",
permission = "mobarena.setup.autogenerate"
)
public class AutoGenerateCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the arguments, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma autogenerate <arena>");
return true;
}
// Check if arena already exists.
Arena arena = am.getArenaWithName(arg1);
if (arena != null) {
Messenger.tellPlayer(sender, "An arena with that name already exists.");
return true;
}
if (!MAUtils.doooooItHippieMonster(p.getLocation(), 13, arg1, am.getPlugin())) {
Messenger.tellPlayer(sender, "Could not auto-generate arena.");
return true;
}
Messenger.tellPlayer(sender, "Arena with name '" + arg1 + "' generated.");
return true;
}
}

33
src/com/garbagemule/MobArena/commands/setup/CheckDataCommand.java Normal file
View File

@ -0,0 +1,33 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "checkdata",
pattern = "checkdata",
usage = "/ma checkdata",
desc = "check if all required points are set up",
permission = "mobarena.setup.checkdata"
)
public class CheckDataCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
Arena arena = arg1.equals("") ? am.getSelectedArena() : am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
arena.getRegion().checkData(am.getPlugin(), sender);
return true;
}
}

39
src/com/garbagemule/MobArena/commands/setup/ConfigCommand.java Normal file
View File

@ -0,0 +1,39 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "config",
pattern = "config|cfg",
usage = "/ma config reload|save",
desc = "reload or save the config-file",
permission = "mobarena.setup.config"
)
public class ConfigCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
if (arg1.equals("reload")) {
am.reloadConfig();
Messenger.tellPlayer(sender, "Config reloaded.");
return true;
}
if (arg1.equals("save")) {
am.saveConfig();
Messenger.tellPlayer(sender, "Config saved.");
return true;
}
// Requires an argument.
Messenger.tellPlayer(sender, "Usage: /ma config reload|save");
return false;
}
}

38
src/com/garbagemule/MobArena/commands/setup/ContainersCommand.java Normal file
View File

@ -0,0 +1,38 @@
package com.garbagemule.MobArena.commands.setup;
import java.util.Set;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "containers",
pattern = "(containers|chests)",
usage = "/ma containers",
desc = "list containers for the selected arena",
permission = "mobarena.setup.containers"
)
public class ContainersCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
StringBuffer buffy = new StringBuffer();
Set<String> containers = am.getPlugin().getMAConfig().getKeys("arenas." + am.getSelectedArena().configName() + ".coords.containers");
if (containers != null) {
for (String c : containers) {
buffy.append(c);
buffy.append(" ");
}
}
else {
buffy.append(Msg.MISC_NONE);
}
Messenger.tellPlayer(sender, "Containers for arena '" + am.getSelectedArena().configName() + "': " + buffy.toString());
return true;
}
}

75
src/com/garbagemule/MobArena/commands/setup/EditArenaCommand.java Normal file
View File

@ -0,0 +1,75 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "editarena",
pattern = "edit(arena)?",
usage = "/ma editarena (<arena>) (true|false)",
desc = "set edit mode of an arena",
permission = "mobarena.setup.editarena"
)
public class EditArenaCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
Arena arena;
// No arguments.
if (arg1.equals("")) {
arena = am.getSelectedArena();
arena.setEditMode(!arena.inEditMode());
}
// One argument.
else if (arg2.equals("")) {
// Argument is [true|false]
if (arg1.matches("true|on") || arg1.matches("false|off")) {
arena = am.getSelectedArena();
arena.setEditMode(arg1.equals("true"));
}
// Argument is <arena name>
else {
arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, "There is no arena with that name.");
Messenger.tellPlayer(sender, "Usage: /ma editarena (true|false)");
Messenger.tellPlayer(sender, " or /ma editarena <arena> (true|false)");
return true;
}
arena.setEditMode(!arena.inEditMode());
}
}
// Two arguments
else {
if (!(arg2.matches("true|on") || arg2.matches("false|off"))) {
Messenger.tellPlayer(sender, "Usage: /ma editarena (true|false)");
Messenger.tellPlayer(sender, " or /ma editarena <arena> (true|false)");
return true;
}
arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, "There is no arena with that name.");
Messenger.tellPlayer(sender, "Usage: /ma editarena (true|false)");
Messenger.tellPlayer(sender, " or /ma editarena <arena> (true|false)");
return true;
}
arena.setEditMode(arg2.equals("true"));
}
Messenger.tellPlayer(sender, "Edit mode for arena '" + arena.configName() + "': " + ((arena.inEditMode()) ? ChatColor.GREEN + "true" : ChatColor.RED + "false"));
if (arena.inEditMode()) Messenger.tellPlayer(sender, "Remember to turn it back off after editing!");
return true;
}
}

56
src/com/garbagemule/MobArena/commands/setup/ExpandLobbyRegionCommand.java Normal file
View File

@ -0,0 +1,56 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "expandlobbyregion",
pattern = "expandlobby(region)?",
usage = "/ma expandlobbyregion <amount> up|down|out",
desc = "expand the arena lobby region",
permission = "mobarena.setup.expandlobbyregion"
)
public class ExpandLobbyRegionCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
if (args.length != 2 || !arg1.matches("(-)?[0-9]+")) {
Messenger.tellPlayer(sender, "Usage: /ma expandlobbyregion <amount> up|down|out");
return false;
}
if (!am.getSelectedArena().getRegion().isLobbyDefined()) {
Messenger.tellPlayer(sender, "You must first define l1 and l2");
return true;
}
if (arg2.equals("up")) {
am.getSelectedArena().getRegion().expandLobbyUp(Integer.parseInt(arg1));
}
else if (arg2.equals("down")) {
am.getSelectedArena().getRegion().expandLobbyDown(Integer.parseInt(arg1));
}
else if (arg2.equals("out")) {
am.getSelectedArena().getRegion().expandLobbyOut(Integer.parseInt(arg1));
}
else {
Messenger.tellPlayer(sender, "Usage: /ma expandlobbyregion <amount> up|down|out");
return true;
}
// In case of a "negative" region, fix it!
am.getSelectedArena().getRegion().fixRegion();
Messenger.tellPlayer(sender, "Lobby region for '" + am.getSelectedArena().configName() + "' expanded " + arg2 + " by " + arg1 + " blocks.");
am.getSelectedArena().getRegion().save();
return true;
}
}

56
src/com/garbagemule/MobArena/commands/setup/ExpandRegionCommand.java Normal file
View File

@ -0,0 +1,56 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "expandregion",
pattern = "expand(region)?",
usage = "/ma expandregion <amount> up|down|out",
desc = "expand the arena region",
permission = "mobarena.setup.expandregion"
)
public class ExpandRegionCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
if (args.length != 2 || !arg1.matches("(-)?[0-9]+")) {
Messenger.tellPlayer(sender, "Usage: /ma expandregion <amount> up|down|out");
return false;
}
if (!am.getSelectedArena().getRegion().isDefined()) {
Messenger.tellPlayer(sender, "You must first define p1 and p2");
return true;
}
if (arg2.equals("up")) {
am.getSelectedArena().getRegion().expandUp(Integer.parseInt(arg1));
}
else if (arg2.equals("down")) {
am.getSelectedArena().getRegion().expandDown(Integer.parseInt(arg1));
}
else if (arg2.equals("out")) {
am.getSelectedArena().getRegion().expandOut(Integer.parseInt(arg1));
}
else {
Messenger.tellPlayer(sender, "Usage: /ma expandregion <amount> up|down|out");
return true;
}
// In case of a "negative" region, fix it!
am.getSelectedArena().getRegion().fixRegion();
Messenger.tellPlayer(sender, "Region for '" + am.getSelectedArena().configName() + "' expanded " + arg2 + " by " + arg1 + " blocks.");
am.getSelectedArena().getRegion().save();
return true;
}
}

57
src/com/garbagemule/MobArena/commands/setup/ListClassPermsCommand.java Normal file
View File

@ -0,0 +1,57 @@
package com.garbagemule.MobArena.commands.setup;
import java.util.Map;
import java.util.Map.Entry;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.TextUtils;
@CommandInfo(
name = "listclassperms",
pattern = "(list)?classperm(.*)s",
usage = "/ma listclassperms <classname>",
desc = "list per-class permissions",
permission = "mobarena.setup.classes"
)
public class ListClassPermsCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument.
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma listclassperms <classname>");
return true;
}
ArenaClass arenaClass = am.getClasses().get(arg1);
String className = TextUtils.camelCase(arg1);
if (arenaClass == null) {
Messenger.tellPlayer(sender, "The class '" + className + "' does not exist.");
return true;
}
Messenger.tellPlayer(sender, "Permissions for '" + className + "':");
Map<String,Boolean> perms = arenaClass.getPermissions();
if (perms.isEmpty()) {
Messenger.tellPlayer(sender, "<none>");
return true;
}
for (Entry<String,Boolean> entry : arenaClass.getPermissions().entrySet()) {
String perm = entry.getKey();
if (!entry.getValue()) {
perm = "^" + perm;
}
Messenger.tellPlayer(sender, "- " + perm);
}
return true;
}
}

34
src/com/garbagemule/MobArena/commands/setup/ListClassesCommand.java Normal file
View File

@ -0,0 +1,34 @@
package com.garbagemule.MobArena.commands.setup;
import java.util.Set;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "listclasses",
pattern = "(list)?class(.)*",
usage = "/ma listclasses",
desc = "list all current classes",
permission = "mobarena.setup.classes"
)
public class ListClassesCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
Messenger.tellPlayer(sender, "Current classes:");
Set<String> classes = am.getClasses().keySet();
if (classes == null || classes.isEmpty()) {
Messenger.tellPlayer(sender, "<none>");
return true;
}
for (String c : classes) {
Messenger.tellPlayer(sender, "- " + c);
}
return true;
}
}

75
src/com/garbagemule/MobArena/commands/setup/ProtectCommand.java Normal file
View File

@ -0,0 +1,75 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "protect",
pattern = "protect",
usage = "/ma protect (<arena>) (true|false)",
desc = "set the protection of an arena",
permission = "mobarena.setup.protect"
)
public class ProtectCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
Arena arena;
// No arguments
if (arg1.equals("")) {
arena = am.getSelectedArena();
arena.setProtected(!arena.isProtected());
}
// One argument
else if (arg2.equals("")) {
// true/false
if (arg1.matches("true|on") || arg1.matches("false|off")) {
arena = am.getSelectedArena();
arena.setProtected(arg1.matches("true|on"));
}
// Arena name
else {
arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, "There is no arena with that name.");
Messenger.tellPlayer(sender, "Usage: /ma protect (true|false)");
Messenger.tellPlayer(sender, " or /ma protect <arena> (true|false)");
return true;
}
arena.setProtected(!arena.isProtected());
}
}
// Two arguments
else {
if (!(arg2.matches("true|on") || arg2.matches("false|off"))) {
Messenger.tellPlayer(sender, "Usage: /ma protect (true|false)");
Messenger.tellPlayer(sender, " or /ma protect <arena name> (true|false)");
return true;
}
arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, "There is no arena with that name.");
Messenger.tellPlayer(sender, "Usage: /ma protect (true|false)");
Messenger.tellPlayer(sender, " or /ma protect <arena name> (true|false)");
return true;
}
arena.setProtected(arg2.equals("true"));
}
arena.getSettings().getParent().save();
Messenger.tellPlayer(sender, "Protection for arena '" + arena.configName() + "': " + ((arena.isProtected()) ? ChatColor.GREEN + "on" : ChatColor.RED + "off"));
return true;
}
}

50
src/com/garbagemule/MobArena/commands/setup/RemoveArenaCommand.java Normal file
View File

@ -0,0 +1,50 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "removearena",
pattern = "(del(.)*|r(e)?m(ove)?)arena",
usage = "/ma removearena <arena>",
desc = "remove an arena",
permission = "mobarena.setup.removearena"
)
public class RemoveArenaCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma removearena <arena>");
return false;
}
if (am.getArenas().size() == 1) {
Messenger.tellPlayer(sender, "At least one arena must exist.");
return false;
}
Arena arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, "There is no arena with that name.");
return false;
}
am.removeArenaNode(arena);
if (am.getSelectedArena().equals(arena)) {
am.setSelectedArena(am.getArenas().get(0));
}
Messenger.tellPlayer(sender, "Arena '" + arena.configName() + "' deleted.");
return true;
}
}

42
src/com/garbagemule/MobArena/commands/setup/RemoveClassCommand.java Normal file
View File

@ -0,0 +1,42 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.TextUtils;
@CommandInfo(
name = "removeclass",
pattern = "(del(.)*|r(e)?m(ove)?)class",
usage = "/ma removeclass <classname>",
desc = "remove the given class",
permission = "mobarena.setup.classes"
)
public class RemoveClassCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument.
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma removeclass <classname>");
return false;
}
// Find the class
ArenaClass arenaClass = am.getClasses().get(arg1);
String className = TextUtils.camelCase(arg1);
if (arenaClass == null) {
Messenger.tellPlayer(sender, "The class '" + className + "' does not exist.");
return false;
}
am.removeClassNode(className);
Messenger.tellPlayer(sender, "Removed class '" + className + "'.");
return true;
}
}

47
src/com/garbagemule/MobArena/commands/setup/RemoveClassPermCommand.java Normal file
View File

@ -0,0 +1,47 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.TextUtils;
@CommandInfo(
name = "removeclassperm",
pattern = "(del(.)*|r(e)?m(ove)?)(class)?perm(.*)",
usage = "/ma removeclassperm <classname> <permission>",
desc = "remove a per-class permission",
permission = "mobarena.setup.classes"
)
public class RemoveClassPermCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
if (arg1.equals("") || arg2.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma removeclassperm <classname> <permission>");
return false;
}
// Grab the arena class
ArenaClass arenaClass = am.getClasses().get(arg1);
if (arenaClass == null) {
Messenger.tellPlayer(sender, "The class '" + TextUtils.camelCase(arg1) + "' does not exist.");
return false;
}
// Remove the permission.
if (am.removeClassPermission(arg1, arg2)) {
Messenger.tellPlayer(sender, "Removed permission '" + arg2 + "' from class '" + TextUtils.camelCase(arg1) + "'.");
return true;
}
// If it wasn't removed, notify.
Messenger.tellPlayer(sender, "Permission '" + arg2 + "' was NOT removed from class '" + TextUtils.camelCase(arg1) + "'.");
return false;
}
}

35
src/com/garbagemule/MobArena/commands/setup/RemoveContainerCommand.java Normal file
View File

@ -0,0 +1,35 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "removecontainer",
pattern = "(del(.)*|r(e)?m(ove)?)(container|chest)",
usage = "/ma removecontainer <point name>",
desc = "remove a container from the selected arena",
permission = "mobarena.setup.containers"
)
public class RemoveContainerCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (!arg1.matches("^[a-zA-Z][a-zA-Z0-9]*$")) {
Messenger.tellPlayer(sender, "Usage: /ma removecontainer <point name>");
return false;
}
if (am.getSelectedArena().getRegion().removeSpawn(arg1))
Messenger.tellPlayer(sender, "Container " + arg1 + " removed for arena '" + am.getSelectedArena().configName() + "'");
else
Messenger.tellPlayer(sender, "Could not find the container " + arg1 + "for the arena '" + am.getSelectedArena().configName() + "'");
return true;
}
}

35
src/com/garbagemule/MobArena/commands/setup/RemoveSpawnpointCommand.java Normal file
View File

@ -0,0 +1,35 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "delspawn",
pattern = "(del(.)*|r(e)?m(ove)?)spawn(point)?",
usage = "/ma delspawn <point name>",
desc = "add a new arena",
permission = "mobarena.setup.spawnpoints"
)
public class RemoveSpawnpointCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (!arg1.matches("^[a-zA-Z][a-zA-Z0-9]*$")) {
Messenger.tellPlayer(sender, "Usage: /ma removespawn <point name>");
return true;
}
if (am.getSelectedArena().getRegion().removeSpawn(arg1))
Messenger.tellPlayer(sender, "Spawnpoint " + arg1 + " removed for arena '" + am.getSelectedArena().configName() + "'");
else
Messenger.tellPlayer(sender, "Could not find the spawnpoint " + arg1 + "for the arena '" + am.getSelectedArena().configName() + "'");
return true;
}
}

41
src/com/garbagemule/MobArena/commands/setup/SetArenaCommand.java Normal file
View File

@ -0,0 +1,41 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "setarena",
pattern = "(set|select)arena",
usage = "/ma setarena <arena>",
desc = "set an arena as the selected arena",
permission = "mobarena.setup.setarena"
)
public class SetArenaCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Require an argument
if (arg1.equals("")) {
Messenger.tellPlayer(sender, "Usage: /ma setarena <arena>");
return false;
}
Arena arena = am.getArenaWithName(arg1);
if (arena != null) {
am.setSelectedArena(arena);
Messenger.tellPlayer(sender, "Currently selected arena: " + arena.configName());
}
else {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
}
return true;
}
}

65
src/com/garbagemule/MobArena/commands/setup/SetClassCommand.java Normal file
View File

@ -0,0 +1,65 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
import com.garbagemule.MobArena.util.TextUtils;
@CommandInfo(
name = "setclass",
pattern = "setclass|saveclass",
usage = "/ma setclass (safe) <classname>",
desc = "save your inventory as a class",
permission = "mobarena.setup.classes"
)
public class SetClassCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String arg2 = (args.length > 1 ? args[1] : "");
// Cast the sender.
Player p = (Player) sender;
// Require an argument.
if (arg1.equals("")) {
Messenger.tellPlayer(p, "Usage: /ma setclass (safe) <classname>");
return true;
}
// Check if we're overwriting.
boolean safe = arg1.equals("safe");
if (safe && arg2.equals("")) {
Messenger.tellPlayer(p, "Usage: /ma setclass (safe) <classname>");
return true;
}
// If so, use arg2, otherwise, use arg1
String className = TextUtils.camelCase(safe ? arg2 : arg1);
// Create the class.
ArenaClass arenaClass = am.createClassNode(className, p.getInventory(), safe);
// If the class is null, it was not created.
if (arenaClass == null) {
Messenger.tellPlayer(p, "That class already exists!");
Messenger.tellPlayer(p, "To overwrite, omit the 'safe' parameter.");
return true;
}
// Otherwise, yay!
Messenger.tellPlayer(p, "Class '" + className + "' set with your current inventory.");
return true;
}
}

41
src/com/garbagemule/MobArena/commands/setup/SetLobbyRegionCommand.java Normal file
View File

@ -0,0 +1,41 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "setlobbyregion",
pattern = "set(lobbyregion|l)",
usage = "/ma setlobbyregion l1|l2",
desc = "set the lobby region points of an arena",
permission = "mobarena.setup.setlobbyregion"
)
public class SetLobbyRegionCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
if (!(arg1.equals("l1") || arg1.equals("l2"))) {
Messenger.tellPlayer(sender, "Usage: /ma setlobbyregion l1|l2");
return true;
}
am.getSelectedArena().getRegion().set(arg1, p.getLocation());
Messenger.tellPlayer(sender, "Lobby region point " + arg1 + " for arena '" + am.getSelectedArena().configName() + "' set.");
return true;
}
}

52
src/com/garbagemule/MobArena/commands/setup/SetRegionCommand.java
View File

@ -2,28 +2,40 @@ package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.*;
public class SetRegionCommand implements MACommand
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "setregion",
pattern = "set(region|p)",
usage = "/ma setregion p1|p2",
desc = "set the region points of an arena",
permission = "mobarena.setup.setregion"
)
public class SetRegionCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "setregion" };
}
@Override
public String getPermission() {
return "mobarena.setup.setregion";
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
return false;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
if (!(arg1.equals("p1") || arg1.equals("p2"))) {
Messenger.tellPlayer(sender, "Usage: /ma setregion p1|p2");
return true;
}
am.getSelectedArena().getRegion().set(arg1, p.getLocation());
Messenger.tellPlayer(sender, "Region point " + arg1 + " for arena '" + am.getSelectedArena().configName() + "' set.");
return true;
}
}

42
src/com/garbagemule/MobArena/commands/setup/SetWarpCommand.java Normal file
View File

@ -0,0 +1,42 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "setwarp",
pattern = "set(warp|point)",
usage = "/ma setwarp arena|lobby|spectator",
desc = "set a warp point for an arena",
permission = "mobarena.setup.setwarp"
)
public class SetWarpCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
if (!(arg1.equals("arena") || arg1.equals("lobby") || arg1.equals("spectator"))) {
Messenger.tellPlayer(sender, "Usage: /ma setwarp arena|lobby|spectator");
return true;
}
am.getSelectedArena().getRegion().set(arg1, p.getLocation());
Messenger.tellPlayer(sender, "Warp point " + arg1 + " was set for arena '" + am.getSelectedArena().configName() + "'");
Messenger.tellPlayer(sender, "Type /ma checkdata to see if you're missing anything...");
return true;
}
}

59
src/com/garbagemule/MobArena/commands/setup/ShowRegionCommand.java Normal file
View File

@ -0,0 +1,59 @@
package com.garbagemule.MobArena.commands.setup;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "showregion",
pattern = "show(region)?",
usage = "/ma showregion (<arena>)",
desc = "show an arena region",
permission = "mobarena.setup.showregion"
)
public class ShowRegionCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
Arena arena;
if (arg1.equals("")) {
arena = am.getArenaAtLocation(p.getLocation());
if (arena == null) {
arena = am.getSelectedArena();
}
if (!arena.getRegion().isDefined()) {
Messenger.tellPlayer(sender, "The region is not defined for the selected arena.");
return false;
}
}
else {
arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
}
arena.getRegion().showRegion(p);
return true;
}
}

38
src/com/garbagemule/MobArena/commands/setup/SpawnpointsCommand.java Normal file
View File

@ -0,0 +1,38 @@
package com.garbagemule.MobArena.commands.setup;
import java.util.Set;
import org.bukkit.command.CommandSender;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "spawnpoints",
pattern = "spawn(point)?s",
usage = "/ma spawnpoints",
desc = "list spawnpoints for the selected arena",
permission = "mobarena.setup.spawnpoints"
)
public class SpawnpointsCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
StringBuffer buffy = new StringBuffer();
Set<String> spawnpoints = am.getPlugin().getMAConfig().getKeys("arenas." + am.getSelectedArena().configName() + ".coords.spawnpoints");
if (spawnpoints != null) {
for (String s : spawnpoints) {
buffy.append(s);
buffy.append(" ");
}
}
else {
buffy.append(Msg.MISC_NONE);
}
Messenger.tellPlayer(sender, "Spawnpoints for arena '" + am.getSelectedArena().configName() + "': " + buffy.toString());
return true;
}
}

63
src/com/garbagemule/MobArena/commands/user/ArenaListCommand.java
View File

@ -4,51 +4,34 @@ import java.util.List;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.*;
public class ArenaListCommand implements MACommand
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "arenalist",
pattern = "arenas|arenal.*|lista.*",
usage = "/ma arenas",
desc = "lists all available arenas",
permission = "mobarena.use.arenalist"
)
public class ArenaListCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "arenas" , "list" };
}
@Override
public String getPermission() {
return "mobarena.use.arenalist";
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
// Grab the arena master and the args.
ArenaMaster am = plugin.getArenaMaster();
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
List<Arena> arenas;
// Get the arenas.
List<Arena> arenas = am.getEnabledAndPermittedArenas(sender);
// Turn the list into a string.
String msg = Msg.MISC_LIST_ARENAS.toString(listToString(arenas));
plugin.tell(sender, msg);
return true;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
}
private <E> String listToString(List<E> list) {
String result = "";
for (E e : list) {
result += e + ", ";
if (Commands.isPlayer(sender)) {
Player p = (Player) sender;
arenas = am.getPermittedArenas(p);
} else {
arenas = am.getArenas();
}
if (result.equals(""))
return Msg.MISC_NONE.toString();
return result.substring(0, result.length() - 2);
String list = MAUtils.listToString(arenas, am.getPlugin());
Messenger.tellPlayer(sender, Msg.MISC_LIST_ARENAS.toString(list));
return true;
}
}

94
src/com/garbagemule/MobArena/commands/user/JoinCommand.java
View File

@ -1,71 +1,71 @@
package com.garbagemule.MobArena.commands.user;
import java.util.*;
import java.util.List;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.*;
public class JoinCommand implements MACommand
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "join",
pattern = "j|jo.*|j.*n",
usage = "/ma join (<arena>)",
desc = "join an arena",
permission = "mobarena.use.join"
)
public class JoinCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "join" , "j" };
}
@Override
public String getPermission() {
return "mobarena.use.join";
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
// Grab the arena master and get the argument.
ArenaMaster am = plugin.getArenaMaster();
String arenaName = (args.length == 1) ? args[0] : null;
// Get all arenas this player is eligible for.
List<Arena> arenas = am.getEnabledAndPermittedArenas(sender);
// If no arenas found, just tell the player it's not enabled.
if (arenas.size() == 0) {
plugin.tell(sender, Msg.JOIN_ARENA_NOT_ENABLED);
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Require an argument in case of multiple arenas.
if (arenaName == null && arenas.size() > 1) {
plugin.tell(sender, Msg.JOIN_ARG_NEEDED);
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
List<Arena> arenas = am.getEnabledArenas();
if (!am.isEnabled() || arenas.size() < 1) {
Messenger.tellPlayer(p, Msg.JOIN_NOT_ENABLED);
return true;
}
// Grab the arena to join
Arena arena = arenas.size() == 1 ? arenas.get(0) : am.getArenaWithName(arg1);
// Run a couple of basic sanity checks
if (!Commands.sanityChecks(p, am, arena, arg1, arenas)) {
return true;
}
// Run a bunch of per-arena sanity checks
if (!arena.canJoin(p)) {
return false;
}
/* At this point in time, if there was no argument, there must be only
* a single arena in the list. If there was an argument, we can safely
* get the arena with that name, because canJoin() will do the rest of
* the sanity checks. */
Arena a = (arenaName == null) ? arenas.get(0) : am.getArenaWithName(arenaName);
// If player is in a boat/minecart, eject!
if (p.isInsideVehicle())
p.leaveVehicle();
// If the arena is null, it doesn't exist.
if (a == null) {
plugin.tell(sender, Msg.ARENA_DOES_NOT_EXIST);
// If player is in a bed, unbed!
if (p.isSleeping()) {
p.kickPlayer("Banned for life... Nah, just don't join from a bed ;)");
return false;
}
// Let the arena itself do the rest of the sanity checking.
if (!a.canJoin(sender)) {
// Join the arena!
if (!arena.playerJoin(p, p.getLocation())) {
return false;
}
// If no problems, let the guy join and notify.
a.playerJoin(sender, sender.getLocation());
plugin.tell(sender, Msg.JOIN_PLAYER_JOINED);
return true;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
}
}

51
src/com/garbagemule/MobArena/commands/user/LeaveCommand.java
View File

@ -2,28 +2,43 @@ package com.garbagemule.MobArena.commands.user;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.*;
public class LeaveCommand implements MACommand
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "leave",
pattern = "l|le((.*))?",
usage = "/ma leave",
desc = "leave the arena",
permission = "mobarena.use.leave"
)
public class LeaveCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "leave" , "l" };
}
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Cast the sender.
Player p = (Player) sender;
@Override
public String getPermission() {
return "mobarena.use.leave";
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
Arena arena = am.getArenaWithPlayer(p);
if (arena == null) {
arena = am.getArenaWithSpectator(p);
if (arena == null) {
Messenger.tellPlayer(p, Msg.LEAVE_NOT_PLAYING);
return false;
}
}
if (arena.playerLeave(p)) {
Messenger.tellPlayer(p, Msg.LEAVE_PLAYER_LEFT);
}
return true;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
}
}

62
src/com/garbagemule/MobArena/commands/user/NotReadyCommand.java
View File

@ -2,28 +2,52 @@ package com.garbagemule.MobArena.commands.user;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.*;
public class NotReadyCommand implements MACommand
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "notready",
pattern = "notr.*|ready",
usage = "/ma notready (<arena>)",
desc = "lists all available arenas",
permission = "mobarena.use.arenalist"
)
public class NotReadyCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "notready" , "check" };
}
@Override
public String getPermission() {
return "mobarena.use.notready";
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any
String arg1 = (args.length > 0 ? args[0] : "");
// The arena to query.
Arena arena = null;
if (!arg1.equals("")) {
arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
}
else if (Commands.isPlayer(sender)) {
Player p = (Player) sender;
arena = am.getArenaWithPlayer(p);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.LEAVE_NOT_PLAYING);
return false;
}
}
else {
Messenger.tellPlayer(sender, "Usage: /ma notready <arena name>");
return false;
}
String list = MAUtils.listToString(arena.getNonreadyPlayers(), am.getPlugin());
Messenger.tellPlayer(sender, Msg.MISC_LIST_PLAYERS.toString(list));
return true;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
}
}

63
src/com/garbagemule/MobArena/commands/user/PlayerListCommand.java
View File

@ -1,29 +1,54 @@
package com.garbagemule.MobArena.commands.user;
import java.util.LinkedList;
import java.util.List;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.*;
public class PlayerListCommand implements MACommand
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "playerlist",
pattern = "player.*|listp.*",
usage = "/ma players (<arena>)",
desc = "lists players in an arena",
permission = "mobarena.use.playerlist"
)
public class PlayerListCommand implements Command
{
@Override
public String[] getNames() {
return new String[] { "who" , "players" };
}
@Override
public String getPermission() {
return "mobarena.use.playerlist";
}
@Override
public boolean execute(MobArenaPlugin plugin, Player sender, String... args) {
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
String list = null;
if (!arg1.equals("")) {
Arena arena = am.getArenaWithName(arg1);
if (arena == null) {
Messenger.tellPlayer(sender, Msg.ARENA_DOES_NOT_EXIST);
return false;
}
list = MAUtils.listToString(arena.getPlayersInArena(), am.getPlugin());
}
else {
StringBuffer buffy = new StringBuffer();
List<Player> players = new LinkedList<Player>();
for (Arena arena : am.getArenas()) {
players.addAll(arena.getPlayersInArena());
}
buffy.append(MAUtils.listToString(players, am.getPlugin()));
list = buffy.toString();
}
Messenger.tellPlayer(sender, Msg.MISC_LIST_PLAYERS.toString(list));
return true;
}
@Override
public boolean executeFromConsole(MobArenaPlugin plugin, CommandSender sender, String... args) {
return false;
}
}

70
src/com/garbagemule/MobArena/commands/user/SpecCommand.java Normal file
View File

@ -0,0 +1,70 @@
package com.garbagemule.MobArena.commands.user;
import java.util.List;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.garbagemule.MobArena.*;
import com.garbagemule.MobArena.commands.*;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.framework.ArenaMaster;
@CommandInfo(
name = "spec",
pattern = "s|spec.*",
usage = "/ma spec (<arena>)",
desc = "spec an arena",
permission = "mobarena.use.spec"
)
public class SpecCommand implements Command
{
@Override
public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
if (!Commands.isPlayer(sender)) {
Messenger.tellPlayer(sender, Msg.MISC_NOT_FROM_CONSOLE);
return false;
}
// Grab the argument, if any.
String arg1 = (args.length > 0 ? args[0] : "");
// Cast the sender.
Player p = (Player) sender;
List<Arena> arenas = am.getEnabledArenas();
if (!am.isEnabled() || arenas.size() < 1) {
Messenger.tellPlayer(p, Msg.JOIN_NOT_ENABLED);
return true;
}
// Grab the arena to join
Arena arena = arenas.size() == 1 ? arenas.get(0) : am.getArenaWithName(arg1);
// Run a couple of basic sanity checks
if (!Commands.sanityChecks(p, am, arena, arg1, arenas)) {
return false;
}
// Run a bunch of arena-specific sanity-checks
if (!arena.canSpec(p)) {
return false;
}
// If player is in a boat/minecart, eject!
if (p.isInsideVehicle())
p.leaveVehicle();
// If player is in a bed, unbed!
if (p.isSleeping()) {
p.kickPlayer("Banned for life... Nah, just don't join from a bed ;)");
return false;
}
// Spectate the arena!
arena.playerSpec(p, p.getLocation());
Messenger.tellPlayer(p, Msg.SPEC_PLAYER_SPECTATE);
return true;
}
}

43
src/com/garbagemule/MobArena/events/ArenaEndEvent.java Normal file
View File

@ -0,0 +1,43 @@
package com.garbagemule.MobArena.events;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.garbagemule.MobArena.framework.Arena;
public class ArenaEndEvent extends Event implements Cancellable
{
private static final long serialVersionUID = -492437066028367597L;
private static final HandlerList handlers = new HandlerList();
private Arena arena;
private boolean cancelled;
public ArenaEndEvent(Arena arena) {
this.arena = arena;
this.cancelled = false;
}
public Arena getArena() {
return arena;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

37
src/com/garbagemule/MobArena/events/ArenaPlayerDeathEvent.java Normal file
View File

@ -0,0 +1,37 @@
package com.garbagemule.MobArena.events;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.garbagemule.MobArena.framework.Arena;
public class ArenaPlayerDeathEvent extends Event
{
private static final long serialVersionUID = 8945689670354700831L;
private static final HandlerList handlers = new HandlerList();
private Player player;
private Arena arena;
public ArenaPlayerDeathEvent(Player player, Arena arena) {
this.player = player;
this.arena = arena;
}
public Player getPlayer() {
return player;
}
public Arena getArena() {
return arena;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

50
src/com/garbagemule/MobArena/events/ArenaPlayerJoinEvent.java Normal file
View File

@ -0,0 +1,50 @@
package com.garbagemule.MobArena.events;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.garbagemule.MobArena.framework.Arena;
public class ArenaPlayerJoinEvent extends Event implements Cancellable
{
private static final long serialVersionUID = -1205905192685201064L;
private static final HandlerList handlers = new HandlerList();
private Player player;
private Arena arena;
private boolean cancelled;
public ArenaPlayerJoinEvent(Player player, Arena arena) {
this.player = player;
this.arena = arena;
this.cancelled = false;
}
public Player getPlayer() {
return player;
}
public Arena getArena() {
return arena;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

50
src/com/garbagemule/MobArena/events/ArenaPlayerLeaveEvent.java Normal file
View File

@ -0,0 +1,50 @@
package com.garbagemule.MobArena.events;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.garbagemule.MobArena.framework.Arena;
public class ArenaPlayerLeaveEvent extends Event implements Cancellable
{
private static final long serialVersionUID = -8942511403871825734L;
private static final HandlerList handlers = new HandlerList();
private Player player;
private Arena arena;
private boolean cancelled;
public ArenaPlayerLeaveEvent(Player player, Arena arena) {
this.player = player;
this.arena = arena;
this.cancelled = false;
}
public Player getPlayer() {
return player;
}
public Arena getArena() {
return arena;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

43
src/com/garbagemule/MobArena/events/ArenaStartEvent.java Normal file
View File

@ -0,0 +1,43 @@
package com.garbagemule.MobArena.events;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.garbagemule.MobArena.framework.Arena;
public class ArenaStartEvent extends Event implements Cancellable
{
private static final long serialVersionUID = 4414065978731456440L;
private static final HandlerList handlers = new HandlerList();
private Arena arena;
private boolean cancelled;
public ArenaStartEvent(Arena arena) {
this.arena = arena;
this.cancelled = false;
}
public Arena getArena() {
return arena;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

55
src/com/garbagemule/MobArena/events/NewWaveEvent.java Normal file
View File

@ -0,0 +1,55 @@
package com.garbagemule.MobArena.events;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.waves.Wave;
public class NewWaveEvent extends Event implements Cancellable
{
private static final long serialVersionUID = -8743818273565357180L;
private static final HandlerList handlers = new HandlerList();
private Arena arena;
private boolean cancelled;
private Wave wave;
private int waveNo;
public NewWaveEvent(Arena arena, Wave wave, int waveNo) {
this.wave = wave;
this.waveNo = waveNo;
}
public Wave getWave() {
return wave;
}
public int getWaveNumber() {
return waveNo;
}
public Arena getArena() {
return arena;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

231
src/com/garbagemule/MobArena/framework/Arena.java Normal file
View File

@ -0,0 +1,231 @@
package com.garbagemule.MobArena.framework;
import java.util.*;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import com.garbagemule.MobArena.ArenaClass;
import com.garbagemule.MobArena.ArenaListenerImpl;
import com.garbagemule.MobArena.ArenaPlayer;
import com.garbagemule.MobArena.MASpawnThread;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.MonsterManager;
import com.garbagemule.MobArena.RewardManager;
import com.garbagemule.MobArena.leaderboards.Leaderboard;
import com.garbagemule.MobArena.region.ArenaRegion;
import com.garbagemule.MobArena.repairable.Repairable;
import com.garbagemule.MobArena.util.config.ConfigSection;
import com.garbagemule.MobArena.util.inventory.InventoryManager;
import com.garbagemule.MobArena.waves.Wave;
import com.garbagemule.MobArena.waves.WaveManager;
public interface Arena
{
/*/////////////////////////////////////////////////////////////////////////
//
// NEW METHODS IN REFACTORING
//
/////////////////////////////////////////////////////////////////////////*/
public ConfigSection getSettings();
public World getWorld();
public void setWorld(World world);
public boolean isEnabled();
public void setEnabled(boolean value);
public boolean isProtected();
public void setProtected(boolean value);
public boolean isRunning();
public boolean inEditMode();
public void setEditMode(boolean value);
public Material getClassLogo(String classname);
public List<ItemStack> getEntryFee();
public Set<Map.Entry<Integer,List<ItemStack>>> getEveryWaveEntrySet();
public List<ItemStack> getAfterWaveReward(int wave);
public Set<Player> getPlayersInArena();
public Set<Player> getPlayersInLobby();
public Set<Player> getReadyPlayersInLobby();
public Set<Player> getSpectators();
public MASpawnThread getSpawnThread();
public WaveManager getWaveManager();
public Location getPlayerEntry(Player p);
public ArenaListenerImpl getEventListener();
public void setLeaderboard(Leaderboard leaderboard);
public ArenaPlayer getArenaPlayer(Player p);
public Set<Block> getBlocks();
public void addBlock(Block b);
public boolean removeBlock(Block b);
public boolean hasPet(Entity e);
public void addRepairable(Repairable r);
public ArenaRegion getRegion();
public InventoryManager getInventoryManager();
public RewardManager getRewardManager();
public MonsterManager getMonsterManager();
public void revivePlayer(Player p);
public void scheduleTask(Runnable r, int delay);
public boolean startArena();
public boolean endArena();
public void forceStart();
public void forceEnd();
public boolean playerJoin(Player p, Location loc);
public void playerReady(Player p);
public boolean playerLeave(Player p);
public void playerDeath(Player p);
public void playerRespawn(Player p);
public Location getRespawnLocation(Player p);
public void playerSpec(Player p, Location loc);
public void storePlayerData(Player p, Location loc);
public void storeContainerContents();
public void restoreContainerContents();
public void movePlayerToLobby(Player p);
public void movePlayerToSpec(Player p);
public void movePlayerToEntry(Player p);
public void discardPlayer(Player p);
public void repairBlocks();
public void queueRepairable(Repairable r);
/*////////////////////////////////////////////////////////////////////
//
// Items & Cleanup
//
////////////////////////////////////////////////////////////////////*/
public void assignClass(Player p, String className);
public void assignRandomClass(Player p);
public void assignClassPermissions(Player p);
public void removeClassPermissions(Player p);
/*////////////////////////////////////////////////////////////////////
//
// Initialization & Checks
//
////////////////////////////////////////////////////////////////////*/
public void restoreRegion();
/*////////////////////////////////////////////////////////////////////
//
// Getters & Misc
//
////////////////////////////////////////////////////////////////////*/
public boolean inArena(Player p);
public boolean inLobby(Player p);
public boolean inSpec(Player p);
public boolean isDead(Player p);
public String configName();
public String arenaName();
public MobArena getPlugin();
public Wave getWave();
public Map<String,ArenaClass> getClasses();
public int getPlayerCount();
public List<Player> getAllPlayers();
public Collection<ArenaPlayer> getArenaPlayerSet();
public List<Player> getNonreadyPlayers();
public boolean canAfford(Player p);
public boolean takeFee(Player p);
public boolean refund(Player p);
public boolean canJoin(Player p);
public boolean canSpec(Player p);
}

10
src/com/garbagemule/MobArena/ArenaListener.java → src/com/garbagemule/MobArena/framework/ArenaListener.java
View File

@ -1,4 +1,4 @@
package com.garbagemule.MobArena;
package com.garbagemule.MobArena.framework;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockIgniteEvent;
@ -19,7 +19,11 @@ import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
public interface ArenaListener
{
{
public enum TeleportResponse {
ALLOW, REJECT, IDGAF
}
public void onBlockBreak(BlockBreakEvent event);
public void onBlockPlace(BlockPlaceEvent event);
public void onBlockIgnite(BlockIgniteEvent event);
@ -35,6 +39,6 @@ public interface ArenaListener
public void onPlayerInteract(PlayerInteractEvent event);
public void onPlayerQuit(PlayerQuitEvent event);
public void onPlayerKick(PlayerKickEvent event);
public void onPlayerTeleport(PlayerTeleportEvent event);
public TeleportResponse onPlayerTeleport(PlayerTeleportEvent event);
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event);
}

136
src/com/garbagemule/MobArena/framework/ArenaMaster.java Normal file
View File

@ -0,0 +1,136 @@
package com.garbagemule.MobArena.framework;
import java.util.List;
import java.util.Map;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.PlayerInventory;
import com.garbagemule.MobArena.ArenaClass;
import com.garbagemule.MobArena.MobArena;
import com.garbagemule.MobArena.framework.Arena;
public interface ArenaMaster
{
/*/////////////////////////////////////////////////////////////////////////
//
// NEW METHODS IN REFACTORING
//
/////////////////////////////////////////////////////////////////////////*/
public MobArena getPlugin();
public boolean isEnabled();
public void setEnabled(boolean value);
public boolean notifyOnUpdates();
public Arena getSelectedArena();
public void setSelectedArena(Arena arena);
public List<Arena> getArenas();
public Map<String,ArenaClass> getClasses();
public void addPlayer(Player p, Arena arena);
public Arena removePlayer(Player p);
public void resetArenaMap();
/*/////////////////////////////////////////////////////////////////////////
//
// Getters
//
/////////////////////////////////////////////////////////////////////////*/
public List<Arena> getEnabledArenas();
public List<Arena> getPermittedArenas(Player p);
public List<Arena> getEnabledAndPermittedArenas(Player p);
public Arena getArenaAtLocation(Location loc);
public List<Arena> getArenasInWorld(World world);
public List<Player> getAllPlayers();
public List<Player> getAllPlayersInArena(String arenaName);
public List<Player> getAllLivingPlayers();
public List<Player> getLivingPlayersInArena(String arenaName);
public Arena getArenaWithPlayer(Player p);
public Arena getArenaWithPlayer(String playerName);
public Arena getArenaWithSpectator(Player p);
public Arena getArenaWithMonster(Entity e);
public Arena getArenaWithPet(Entity e);
public Arena getArenaWithName(String configName);
public boolean isAllowed(String command);
/*/////////////////////////////////////////////////////////////////////////
//
// Initialization
//
/////////////////////////////////////////////////////////////////////////*/
public void initialize();
/**
* Load the global settings.
*/
public void loadSettings();
/**
* Load all class-related stuff.
*/
public void loadClasses();
public ArenaClass createClassNode(String className, PlayerInventory inv, boolean safe);
public void removeClassNode(String className);
public boolean addClassPermission(String className, String perm);
public boolean removeClassPermission(String className, String perm);
/**
* Load all arena-related stuff.
*/
public void loadArenas();
public Arena createArenaNode(String configName, World world);
public void removeArenaNode(Arena arena);
/*/////////////////////////////////////////////////////////////////////////
//
// Update and serialization methods
//
/////////////////////////////////////////////////////////////////////////*/
public void reloadConfig();
public void saveConfig();
}

Some files were not shown because too many files have changed in this diff Show More