U3Games

diff --git a/aCis_gameserver/java/by/leonardoalves/mods/RaidDamage/RaidDamageEntry.java b/aCis_gameserver/java/by/leonardoalves/mods/RaidDamage/RaidDamageEntry.java
new file mode 100644
index 0000000..b9b3094
--- /dev/null
+++ b/aCis_gameserver/java/by/leonardoalves/mods/RaidDamage/RaidDamageEntry.java
@@ -0,0 +1,60 @@
+package by.leonardoalves.mods.RaidDamage;
+
+/**
+ * @author Leonardo Alves
+ *
+ */
+public class RaidDamageEntry implements Comparable<RaidDamageEntry>
+{
+    private final int _playerObjectId;
+    private final int _raidId;
+    
+    private long _totalDamage;
+    private int _hitCount;
+    private long _maxHit;
+    
+    public RaidDamageEntry(int playerObjectId, int raidId) {
+        _playerObjectId = playerObjectId;
+        _raidId = raidId;
+    }
+    
+    public void registerHit(long damage) {
+        _totalDamage += damage;
+        _hitCount++;
+        
+        if (damage > _maxHit)
+            _maxHit = damage;
+    }
+    public int getPlayerId()
+    {
+        return _playerObjectId;
+    }
+
+    public long getTotalDamage()
+    {
+        return _totalDamage;
+    }
+    
+    public long getMaxHit() {
+        return _maxHit;
+    }
+    
+    public int getHitCount()
+    {
+        return _hitCount;
+    }
+    @Override
+    public int compareTo(RaidDamageEntry other) {
+        int result = Long.compare(other._totalDamage, this._totalDamage);
+        
+        if(result != 0)
+            return result;
+        
+        result = Integer.compare(other._hitCount, this._hitCount);
+        
+        if(result != 0)
+            return result;
+        
+        return Long.compare(other._maxHit, this._maxHit);
+    }
+}
diff --git a/aCis_gameserver/java/by/leonardoalves/mods/RaidDamage/RaidDamageTracker.java b/aCis_gameserver/java/by/leonardoalves/mods/RaidDamage/RaidDamageTracker.java
new file mode 100644
index 0000000..031f8fb
--- /dev/null
+++ b/aCis_gameserver/java/by/leonardoalves/mods/RaidDamage/RaidDamageTracker.java
@@ -0,0 +1,30 @@
+package by.leonardoalves.mods.RaidDamage;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Leonardo Alves
+ *
+ */
+public class RaidDamageTracker
+{
+    private final int _raidId;
+    private final Map<Integer, RaidDamageEntry> _entries = new HashMap<>();
+    
+    public RaidDamageTracker(int raidId) {
+        _raidId = raidId;
+    }
+    public void addDamage(int playerObjectId, long damage) {
+        RaidDamageEntry entry = _entries.computeIfAbsent(playerObjectId, id -> new RaidDamageEntry(id, _raidId));
+        entry.registerHit(damage);
+    }
+    public List<RaidDamageEntry> getRanking(){
+        List<RaidDamageEntry> ranking = new ArrayList<>(_entries.values());
+        Collections.sort(ranking);
+        return ranking;
+    }
+}
diff --git a/aCis_gameserver/java/net/sf/l2j/gameserver/model/actor/instance/RaidBoss.java b/aCis_gameserver/java/net/sf/l2j/gameserver/model/actor/instance/RaidBoss.java
new file mode 100644
index 0000000..e1dbf8f
--- /dev/null
+++ b/aCis_gameserver/java/net/sf/l2j/gameserver/model/actor/instance/RaidBoss.java
@@ -0,0 +1,204 @@
import net.sf.l2j.gameserver.model.group.Party;
import net.sf.l2j.gameserver.model.spawn.ASpawn;
import net.sf.l2j.gameserver.network.SystemMessageId;
import net.sf.l2j.gameserver.network.serverpackets.PlaySound;
import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
import net.sf.l2j.gameserver.skills.L2Skill;
	+import by.leonardoalves.mods.RaidDamage.RaidDamageEntry;
+import by.leonardoalves.mods.RaidDamage.RaidDamageTracker;
+
/**
 * This class manages all classic raid bosses.<br>
 * <br>
 * Raid Bosses (RB) are mobs which are supposed to be defeated by a party of several players. It extends most of {@link Monster} aspects.<br>
 * <br>
 * They automatically teleport if out of their initial spawn area, and can randomly attack a Player from their Hate List once attacked.<br>
 * <br>
 * Their looting rights are affected by {@link CommandChannel}s. The first who attacks got the priority over loots. Those rights are lost if no attack has been done for 900sec.
 */
public class RaidBoss extends Monster
{
    private ScheduledFuture<?> _maintenanceTask;
+    private final RaidDamageTracker _damageTracker;
+    
    public RaidBoss(int objectId, NpcTemplate template)
    {
        super(objectId, template);
+        _damageTracker = new RaidDamageTracker(objectId);
+        
        setRaidRelated();
    }
    
+    @SuppressWarnings("null")
+    @Override
+    public void reduceCurrentHp(double damage, Creature attacker, boolean awake, boolean isDOT, L2Skill skill)
+    {
+        super.reduceCurrentHp(damage, attacker, awake, isDOT, skill);
+        
+        if (attacker instanceof Summon || attacker == null || damage <= 0)
+            return;
+        
+        if (attacker != null && damage > 0)
+        {
+            Player player = attacker.getActingPlayer();
+            if (player != null)
+            {    
+                _damageTracker.addDamage(player.getObjectId(), (long) damage);
+            }
+        }
+    }
    
    @Override
    public boolean doDie(Creature killer)
    {
        if (!super.doDie(killer))
            return false;
        
        if (_maintenanceTask != null)
        {
            _maintenanceTask.cancel(false);
            _maintenanceTask = null;
        }
        
+        List<RaidDamageEntry> ranking = _damageTracker.getRanking();
+        announceTopDamage(ranking);
        if (killer != null)
        {
            final Player player = killer.getActingPlayer();
            if (player != null)
            {
                broadcastPacket(SystemMessage.getSystemMessage(SystemMessageId.RAID_WAS_SUCCESSFUL));
                broadcastPacket(new PlaySound("systemmsg_e.1209"));
                
                final Party party = player.getParty();
                if (party != null)
                {
                    for (Player member : party.getMembers())
                    {
                        RaidPointManager.getInstance().addPoints(member, getNpcId(), (getStatus().getLevel() / 2) + Rnd.get(-5, 5));
                        if (member.isNoble())
                            HeroManager.getInstance().setRBkilled(member.getObjectId(), getNpcId());
                    }
                }
                else
                {
                    RaidPointManager.getInstance().addPoints(player, getNpcId(), (getStatus().getLevel() / 2) + Rnd.get(-5, 5));
                    if (player.isNoble())
                        HeroManager.getInstance().setRBkilled(player.getObjectId(), getNpcId());
                }
            }
        }
        // TODO implement SpawnManager or ASpawn notification
        // RaidBossManager.getInstance().onDeath(this);
        return true;
    }
+    private void announceTopDamage(List<RaidDamageEntry> ranking)
+    {
+        World.announceToOnlinePlayers("== Top Damage - " + getName() + " ==");
+
+        for (int i = 0; i < Math.min(10, ranking.size()); i++)
+        {
+            RaidDamageEntry entry = ranking.get(i);
+            Player p = World.getInstance().getPlayer(entry.getPlayerId());
+
+            if (p != null)
+            {
+                World.announceToOnlinePlayers(
+                    String.format(
+                        "%d° %s - Total: %.2f | Maior Hit: %.2f",
+                        (i + 1),
+                        p.getName(),
+                        (double) entry.getTotalDamage(),
+                        (double) entry.getMaxHit()
+                    )
+                );
+            }
+        }
+    }
+
+
    @Override
    public void deleteMe()
    {
        if (_maintenanceTask != null)
        {
            _maintenanceTask.cancel(false);
            _maintenanceTask = null;
        }
        
        super.deleteMe();
    }
}