Project update.
This commit is contained in:
MobiusDev
@ -0,0 +1,172 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.Statement;
|
||||
import java.util.Collection;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentSkipListMap;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.enums.ChatType;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
|
||||
import com.l2jmobius.gameserver.model.announce.Announcement;
|
||||
import com.l2jmobius.gameserver.model.announce.AnnouncementType;
|
||||
import com.l2jmobius.gameserver.model.announce.AutoAnnouncement;
|
||||
import com.l2jmobius.gameserver.model.announce.IAnnouncement;
|
||||
import com.l2jmobius.gameserver.network.serverpackets.CreatureSay;
|
||||
|
||||
/**
|
||||
* Loads announcements from database.
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public final class AnnouncementsTable
|
||||
{
|
||||
private static Logger LOGGER = Logger.getLogger(AnnouncementsTable.class.getName());
|
||||
|
||||
private final Map<Integer, IAnnouncement> _announcements = new ConcurrentSkipListMap<>();
|
||||
|
||||
protected AnnouncementsTable()
|
||||
{
|
||||
load();
|
||||
}
|
||||
|
||||
private void load()
|
||||
{
|
||||
_announcements.clear();
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement st = con.createStatement();
|
||||
ResultSet rset = st.executeQuery("SELECT * FROM announcements"))
|
||||
{
|
||||
while (rset.next())
|
||||
{
|
||||
final AnnouncementType type = AnnouncementType.findById(rset.getInt("type"));
|
||||
final Announcement announce;
|
||||
switch (type)
|
||||
{
|
||||
case NORMAL:
|
||||
case CRITICAL:
|
||||
{
|
||||
announce = new Announcement(rset);
|
||||
break;
|
||||
}
|
||||
case AUTO_NORMAL:
|
||||
case AUTO_CRITICAL:
|
||||
{
|
||||
announce = new AutoAnnouncement(rset);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
_announcements.put(announce.getId(), announce);
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Failed loading announcements:", e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sending all announcements to the player
|
||||
* @param player
|
||||
*/
|
||||
public void showAnnouncements(L2PcInstance player)
|
||||
{
|
||||
sendAnnouncements(player, AnnouncementType.NORMAL);
|
||||
sendAnnouncements(player, AnnouncementType.CRITICAL);
|
||||
sendAnnouncements(player, AnnouncementType.EVENT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends all announcements to the player by the specified type
|
||||
* @param player
|
||||
* @param type
|
||||
*/
|
||||
public void sendAnnouncements(L2PcInstance player, AnnouncementType type)
|
||||
{
|
||||
for (IAnnouncement announce : _announcements.values())
|
||||
{
|
||||
if (announce.isValid() && (announce.getType() == type))
|
||||
{
|
||||
player.sendPacket(new CreatureSay(0, //
|
||||
type == AnnouncementType.CRITICAL ? ChatType.CRITICAL_ANNOUNCE : ChatType.ANNOUNCEMENT, //
|
||||
player.getName(), announce.getContent()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds announcement
|
||||
* @param announce
|
||||
*/
|
||||
public void addAnnouncement(IAnnouncement announce)
|
||||
{
|
||||
if (announce.storeMe())
|
||||
{
|
||||
_announcements.put(announce.getId(), announce);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes announcement by id
|
||||
* @param id
|
||||
* @return {@code true} if announcement exists and was deleted successfully, {@code false} otherwise.
|
||||
*/
|
||||
public boolean deleteAnnouncement(int id)
|
||||
{
|
||||
final IAnnouncement announce = _announcements.remove(id);
|
||||
return (announce != null) && announce.deleteMe();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param id
|
||||
* @return {@link IAnnouncement} by id
|
||||
*/
|
||||
public IAnnouncement getAnnounce(int id)
|
||||
{
|
||||
return _announcements.get(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {@link Collection} containing all announcements
|
||||
*/
|
||||
public Collection<IAnnouncement> getAllAnnouncements()
|
||||
{
|
||||
return _announcements.values();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Single instance of {@link AnnouncementsTable}
|
||||
*/
|
||||
public static AnnouncementsTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final AnnouncementsTable _instance = new AnnouncementsTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,292 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
|
||||
|
||||
/**
|
||||
* Loads name and access level for all players.
|
||||
* @version 2005/03/27
|
||||
*/
|
||||
public class CharNameTable
|
||||
{
|
||||
private static Logger _log = Logger.getLogger(CharNameTable.class.getName());
|
||||
|
||||
private final Map<Integer, String> _chars = new ConcurrentHashMap<>();
|
||||
private final Map<Integer, Integer> _accessLevels = new ConcurrentHashMap<>();
|
||||
|
||||
protected CharNameTable()
|
||||
{
|
||||
if (Config.CACHE_CHAR_NAMES)
|
||||
{
|
||||
loadAll();
|
||||
}
|
||||
}
|
||||
|
||||
public final void addName(L2PcInstance player)
|
||||
{
|
||||
if (player != null)
|
||||
{
|
||||
addName(player.getObjectId(), player.getName());
|
||||
_accessLevels.put(player.getObjectId(), player.getAccessLevel().getLevel());
|
||||
}
|
||||
}
|
||||
|
||||
private final void addName(int objectId, String name)
|
||||
{
|
||||
if (name != null)
|
||||
{
|
||||
if (!name.equals(_chars.get(objectId)))
|
||||
{
|
||||
_chars.put(objectId, name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public final void removeName(int objId)
|
||||
{
|
||||
_chars.remove(objId);
|
||||
_accessLevels.remove(objId);
|
||||
}
|
||||
|
||||
public final int getIdByName(String name)
|
||||
{
|
||||
if ((name == null) || name.isEmpty())
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (Entry<Integer, String> entry : _chars.entrySet())
|
||||
{
|
||||
if (entry.getValue().equalsIgnoreCase(name))
|
||||
{
|
||||
return entry.getKey();
|
||||
}
|
||||
}
|
||||
|
||||
if (Config.CACHE_CHAR_NAMES)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
int id = -1;
|
||||
int accessLevel = 0;
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT charId,accesslevel FROM characters WHERE char_name=?"))
|
||||
{
|
||||
ps.setString(1, name);
|
||||
try (ResultSet rs = ps.executeQuery())
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
id = rs.getInt(1);
|
||||
accessLevel = rs.getInt(2);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char name: " + e.getMessage(), e);
|
||||
}
|
||||
|
||||
if (id > 0)
|
||||
{
|
||||
_chars.put(id, name);
|
||||
_accessLevels.put(id, accessLevel);
|
||||
return id;
|
||||
}
|
||||
|
||||
return -1; // not found
|
||||
}
|
||||
|
||||
public final String getNameById(int id)
|
||||
{
|
||||
if (id <= 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
String name = _chars.get(id);
|
||||
if (name != null)
|
||||
{
|
||||
return name;
|
||||
}
|
||||
|
||||
if (Config.CACHE_CHAR_NAMES)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT char_name,accesslevel FROM characters WHERE charId=?"))
|
||||
{
|
||||
ps.setInt(1, id);
|
||||
try (ResultSet rset = ps.executeQuery())
|
||||
{
|
||||
if (rset.next())
|
||||
{
|
||||
name = rset.getString(1);
|
||||
_chars.put(id, name);
|
||||
_accessLevels.put(id, rset.getInt(2));
|
||||
return name;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char id: " + e.getMessage(), e);
|
||||
}
|
||||
|
||||
return null; // not found
|
||||
}
|
||||
|
||||
public final int getAccessLevelById(int objectId)
|
||||
{
|
||||
if (getNameById(objectId) != null)
|
||||
{
|
||||
return _accessLevels.get(objectId);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
public synchronized boolean doesCharNameExist(String name)
|
||||
{
|
||||
boolean result = true;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT account_name FROM characters WHERE char_name=?"))
|
||||
{
|
||||
ps.setString(1, name);
|
||||
try (ResultSet rs = ps.executeQuery())
|
||||
{
|
||||
result = rs.next();
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing charname: " + e.getMessage(), e);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public int getAccountCharacterCount(String account)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT COUNT(char_name) FROM characters WHERE account_name=?"))
|
||||
{
|
||||
ps.setString(1, account);
|
||||
try (ResultSet rset = ps.executeQuery())
|
||||
{
|
||||
while (rset.next())
|
||||
{
|
||||
return rset.getInt(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char count: " + e.getMessage(), e);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
public int getLevelById(int objectId)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT level FROM characters WHERE charId = ?"))
|
||||
{
|
||||
ps.setInt(1, objectId);
|
||||
try (ResultSet rset = ps.executeQuery())
|
||||
{
|
||||
while (rset.next())
|
||||
{
|
||||
return rset.getInt(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char count: " + e.getMessage(), e);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
public int getClassIdById(int objectId)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT classid FROM characters WHERE charId = ?"))
|
||||
{
|
||||
ps.setInt(1, objectId);
|
||||
try (ResultSet rset = ps.executeQuery())
|
||||
{
|
||||
while (rset.next())
|
||||
{
|
||||
return rset.getInt(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing char count: " + e.getMessage(), e);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
private void loadAll()
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery("SELECT charId, char_name, accesslevel FROM characters"))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
final int id = rs.getInt(1);
|
||||
_chars.put(id, rs.getString(2));
|
||||
_accessLevels.put(id, rs.getInt(3));
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": Could not load char name: " + e.getMessage(), e);
|
||||
}
|
||||
_log.info(getClass().getSimpleName() + ": Loaded " + _chars.size() + " char names.");
|
||||
}
|
||||
|
||||
public static CharNameTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final CharNameTable _instance = new CharNameTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,256 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.data.xml.impl.NpcData;
|
||||
import com.l2jmobius.gameserver.data.xml.impl.PetDataTable;
|
||||
import com.l2jmobius.gameserver.datatables.SkillData;
|
||||
import com.l2jmobius.gameserver.model.L2PetData;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PetInstance;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2ServitorInstance;
|
||||
import com.l2jmobius.gameserver.model.actor.templates.L2NpcTemplate;
|
||||
import com.l2jmobius.gameserver.model.items.instance.L2ItemInstance;
|
||||
import com.l2jmobius.gameserver.model.skills.Skill;
|
||||
import com.l2jmobius.gameserver.network.serverpackets.PetItemList;
|
||||
|
||||
/**
|
||||
* @author Nyaran
|
||||
*/
|
||||
public class CharSummonTable
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(CharSummonTable.class.getName());
|
||||
private static final Map<Integer, Integer> _pets = new ConcurrentHashMap<>();
|
||||
private static final Map<Integer, Set<Integer>> _servitors = new ConcurrentHashMap<>();
|
||||
|
||||
// SQL
|
||||
private static final String INIT_PET = "SELECT ownerId, item_obj_id FROM pets WHERE restore = 'true'";
|
||||
private static final String INIT_SUMMONS = "SELECT ownerId, summonId FROM character_summons";
|
||||
private static final String LOAD_SUMMON = "SELECT summonSkillId, summonId, curHp, curMp, time FROM character_summons WHERE ownerId = ?";
|
||||
private static final String REMOVE_SUMMON = "DELETE FROM character_summons WHERE ownerId = ? and summonId = ?";
|
||||
private static final String SAVE_SUMMON = "REPLACE INTO character_summons (ownerId,summonId,summonSkillId,curHp,curMp,time) VALUES (?,?,?,?,?,?)";
|
||||
|
||||
public Map<Integer, Integer> getPets()
|
||||
{
|
||||
return _pets;
|
||||
}
|
||||
|
||||
public Map<Integer, Set<Integer>> getServitors()
|
||||
{
|
||||
return _servitors;
|
||||
}
|
||||
|
||||
public void init()
|
||||
{
|
||||
if (Config.RESTORE_SERVITOR_ON_RECONNECT)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery(INIT_SUMMONS))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
_servitors.computeIfAbsent(rs.getInt("ownerId"), k -> ConcurrentHashMap.newKeySet()).add(rs.getInt("summonId"));
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Error while loading saved servitor: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
if (Config.RESTORE_PET_ON_RECONNECT)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery(INIT_PET))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
_pets.put(rs.getInt("ownerId"), rs.getInt("item_obj_id"));
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Error while loading saved pet: " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void removeServitor(L2PcInstance activeChar, int summonObjectId)
|
||||
{
|
||||
_servitors.computeIfPresent(activeChar.getObjectId(), (k, v) ->
|
||||
{
|
||||
v.remove(summonObjectId);
|
||||
return !v.isEmpty() ? v : null;
|
||||
});
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement(REMOVE_SUMMON))
|
||||
{
|
||||
ps.setInt(1, activeChar.getObjectId());
|
||||
ps.setInt(2, summonObjectId);
|
||||
ps.execute();
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Summon cannot be removed: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
public void restorePet(L2PcInstance activeChar)
|
||||
{
|
||||
final L2ItemInstance item = activeChar.getInventory().getItemByObjectId(_pets.get(activeChar.getObjectId()));
|
||||
if (item == null)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Null pet summoning item for: " + activeChar);
|
||||
return;
|
||||
}
|
||||
final L2PetData petData = PetDataTable.getInstance().getPetDataByItemId(item.getId());
|
||||
if (petData == null)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Null pet data for: " + activeChar + " and summoning item: " + item);
|
||||
return;
|
||||
}
|
||||
final L2NpcTemplate npcTemplate = NpcData.getInstance().getTemplate(petData.getNpcId());
|
||||
if (npcTemplate == null)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Null pet NPC template for: " + activeChar + " and pet Id:" + petData.getNpcId());
|
||||
return;
|
||||
}
|
||||
|
||||
final L2PetInstance pet = L2PetInstance.spawnPet(npcTemplate, activeChar, item);
|
||||
if (pet == null)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Null pet instance for: " + activeChar + " and pet NPC template:" + npcTemplate);
|
||||
return;
|
||||
}
|
||||
|
||||
pet.setShowSummonAnimation(true);
|
||||
pet.setTitle(activeChar.getName());
|
||||
|
||||
if (!pet.isRespawned())
|
||||
{
|
||||
pet.setCurrentHp(pet.getMaxHp());
|
||||
pet.setCurrentMp(pet.getMaxMp());
|
||||
pet.getStat().setExp(pet.getExpForThisLevel());
|
||||
pet.setCurrentFed(pet.getMaxFed());
|
||||
}
|
||||
|
||||
pet.setRunning();
|
||||
|
||||
if (!pet.isRespawned())
|
||||
{
|
||||
pet.storeMe();
|
||||
}
|
||||
|
||||
item.setEnchantLevel(pet.getLevel());
|
||||
activeChar.setPet(pet);
|
||||
pet.spawnMe(activeChar.getX() + 50, activeChar.getY() + 100, activeChar.getZ());
|
||||
pet.startFeed();
|
||||
pet.setFollowStatus(true);
|
||||
pet.getOwner().sendPacket(new PetItemList(pet.getInventory().getItems()));
|
||||
pet.broadcastStatusUpdate();
|
||||
}
|
||||
|
||||
public void restoreServitor(L2PcInstance activeChar)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement(LOAD_SUMMON))
|
||||
{
|
||||
ps.setInt(1, activeChar.getObjectId());
|
||||
try (ResultSet rs = ps.executeQuery())
|
||||
{
|
||||
Skill skill;
|
||||
while (rs.next())
|
||||
{
|
||||
final int summonObjId = rs.getInt("summonId");
|
||||
final int skillId = rs.getInt("summonSkillId");
|
||||
final int curHp = rs.getInt("curHp");
|
||||
final int curMp = rs.getInt("curMp");
|
||||
final int time = rs.getInt("time");
|
||||
|
||||
skill = SkillData.getInstance().getSkill(skillId, activeChar.getSkillLevel(skillId));
|
||||
if ((skill == null) || !activeChar.hasServitor(summonObjId))
|
||||
{
|
||||
removeServitor(activeChar, summonObjId);
|
||||
return;
|
||||
}
|
||||
|
||||
skill.applyEffects(activeChar, activeChar);
|
||||
|
||||
final L2ServitorInstance summon = (L2ServitorInstance) activeChar.getServitor(summonObjId);
|
||||
summon.setCurrentHp(curHp);
|
||||
summon.setCurrentMp(curMp);
|
||||
summon.setLifeTimeRemaining(time);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Servitor cannot be restored: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
public void saveSummon(L2ServitorInstance summon)
|
||||
{
|
||||
if ((summon == null) || (summon.getLifeTimeRemaining() <= 0))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_servitors.computeIfAbsent(summon.getOwner().getObjectId(), k -> ConcurrentHashMap.newKeySet()).add(summon.getObjectId());
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement(SAVE_SUMMON))
|
||||
{
|
||||
ps.setInt(1, summon.getOwner().getObjectId());
|
||||
ps.setInt(2, summon.getObjectId());
|
||||
ps.setInt(3, summon.getReferenceSkill());
|
||||
ps.setInt(4, (int) Math.round(summon.getCurrentHp()));
|
||||
ps.setInt(5, (int) Math.round(summon.getCurrentMp()));
|
||||
ps.setInt(6, summon.getLifeTimeRemaining());
|
||||
ps.execute();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Failed to store summon: " + summon + " from " + summon.getOwner() + ", error: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
public static CharSummonTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final CharSummonTable _instance = new CharSummonTable();
|
||||
}
|
||||
}
|
||||
557
trunk/java/com/l2jmobius/gameserver/data/sql/impl/ClanTable.java
Normal file
557
trunk/java/com/l2jmobius/gameserver/data/sql/impl/ClanTable.java
Normal file
@ -0,0 +1,557 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.Statement;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.ThreadPoolManager;
|
||||
import com.l2jmobius.gameserver.communitybbs.Manager.ForumsBBSManager;
|
||||
import com.l2jmobius.gameserver.enums.UserInfoType;
|
||||
import com.l2jmobius.gameserver.idfactory.IdFactory;
|
||||
import com.l2jmobius.gameserver.instancemanager.CHSiegeManager;
|
||||
import com.l2jmobius.gameserver.instancemanager.ClanHallAuctionManager;
|
||||
import com.l2jmobius.gameserver.instancemanager.FortManager;
|
||||
import com.l2jmobius.gameserver.instancemanager.FortSiegeManager;
|
||||
import com.l2jmobius.gameserver.instancemanager.SiegeManager;
|
||||
import com.l2jmobius.gameserver.model.ClanPrivilege;
|
||||
import com.l2jmobius.gameserver.model.L2Clan;
|
||||
import com.l2jmobius.gameserver.model.L2ClanMember;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
|
||||
import com.l2jmobius.gameserver.model.entity.Auction;
|
||||
import com.l2jmobius.gameserver.model.entity.Fort;
|
||||
import com.l2jmobius.gameserver.model.entity.FortSiege;
|
||||
import com.l2jmobius.gameserver.model.entity.Siege;
|
||||
import com.l2jmobius.gameserver.model.entity.clanhall.SiegableHall;
|
||||
import com.l2jmobius.gameserver.model.events.EventDispatcher;
|
||||
import com.l2jmobius.gameserver.model.events.impl.character.player.clan.OnPlayerClanCreate;
|
||||
import com.l2jmobius.gameserver.model.events.impl.character.player.clan.OnPlayerClanDestroy;
|
||||
import com.l2jmobius.gameserver.model.events.impl.clan.OnClanWarFinish;
|
||||
import com.l2jmobius.gameserver.model.events.impl.clan.OnClanWarStart;
|
||||
import com.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import com.l2jmobius.gameserver.network.serverpackets.PledgeShowInfoUpdate;
|
||||
import com.l2jmobius.gameserver.network.serverpackets.PledgeShowMemberListAll;
|
||||
import com.l2jmobius.gameserver.network.serverpackets.PledgeShowMemberListUpdate;
|
||||
import com.l2jmobius.gameserver.network.serverpackets.SystemMessage;
|
||||
import com.l2jmobius.gameserver.util.Util;
|
||||
import com.l2jmobius.util.EnumIntBitmask;
|
||||
|
||||
/**
|
||||
* This class loads the clan related data.
|
||||
*/
|
||||
public class ClanTable
|
||||
{
|
||||
private static final Logger _log = Logger.getLogger(ClanTable.class.getName());
|
||||
private final Map<Integer, L2Clan> _clans = new ConcurrentHashMap<>();
|
||||
|
||||
protected ClanTable()
|
||||
{
|
||||
// forums has to be loaded before clan data, because of last forum id used should have also memo included
|
||||
if (Config.ENABLE_COMMUNITY_BOARD)
|
||||
{
|
||||
ForumsBBSManager.getInstance().initRoot();
|
||||
}
|
||||
|
||||
L2Clan clan;
|
||||
// Count the clans
|
||||
int clanCount = 0;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery("SELECT clan_id FROM clan_data"))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
final int clanId = rs.getInt("clan_id");
|
||||
_clans.put(clanId, new L2Clan(clanId));
|
||||
clan = getClan(clanId);
|
||||
if (clan.getDissolvingExpiryTime() != 0)
|
||||
{
|
||||
scheduleRemoveClan(clan.getId());
|
||||
}
|
||||
clanCount++;
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
_log.log(Level.SEVERE, "Error restoring ClanTable.", e);
|
||||
}
|
||||
_log.info(getClass().getSimpleName() + ": Restored " + clanCount + " clans from the database.");
|
||||
allianceCheck();
|
||||
restorewars();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the clans.
|
||||
* @return the clans
|
||||
*/
|
||||
public Collection<L2Clan> getClans()
|
||||
{
|
||||
return _clans.values();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the clan count.
|
||||
* @return the clan count
|
||||
*/
|
||||
public int getClanCount()
|
||||
{
|
||||
return _clans.size();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param clanId
|
||||
* @return
|
||||
*/
|
||||
public L2Clan getClan(int clanId)
|
||||
{
|
||||
return _clans.get(clanId);
|
||||
}
|
||||
|
||||
public L2Clan getClanByName(String clanName)
|
||||
{
|
||||
return getClans().stream().filter(c -> c.getName().equalsIgnoreCase(clanName)).findFirst().orElse(null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new clan and store clan info to database
|
||||
* @param player
|
||||
* @param clanName
|
||||
* @return NULL if clan with same name already exists
|
||||
*/
|
||||
public L2Clan createClan(L2PcInstance player, String clanName)
|
||||
{
|
||||
if (null == player)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (Config.DEBUG)
|
||||
{
|
||||
_log.info(getClass().getSimpleName() + ": " + player.getObjectId() + "(" + player.getName() + ") requested a clan creation.");
|
||||
}
|
||||
|
||||
if (10 > player.getLevel())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_DO_NOT_MEET_THE_CRITERIA_IN_ORDER_TO_CREATE_A_CLAN);
|
||||
return null;
|
||||
}
|
||||
if (0 != player.getClanId())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_HAVE_FAILED_TO_CREATE_A_CLAN);
|
||||
return null;
|
||||
}
|
||||
if (System.currentTimeMillis() < player.getClanCreateExpiryTime())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_MUST_WAIT_10_DAYS_BEFORE_CREATING_A_NEW_CLAN);
|
||||
return null;
|
||||
}
|
||||
if (!Util.isAlphaNumeric(clanName) || (2 > clanName.length()))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.CLAN_NAME_IS_INVALID);
|
||||
return null;
|
||||
}
|
||||
if (16 < clanName.length())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.CLAN_NAME_S_LENGTH_IS_INCORRECT);
|
||||
return null;
|
||||
}
|
||||
|
||||
if (null != getClanByName(clanName))
|
||||
{
|
||||
// clan name is already taken
|
||||
final SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_ALREADY_EXISTS);
|
||||
sm.addString(clanName);
|
||||
player.sendPacket(sm);
|
||||
return null;
|
||||
}
|
||||
|
||||
final L2Clan clan = new L2Clan(IdFactory.getInstance().getNextId(), clanName);
|
||||
final L2ClanMember leader = new L2ClanMember(clan, player);
|
||||
clan.setLeader(leader);
|
||||
leader.setPlayerInstance(player);
|
||||
clan.store();
|
||||
player.setClan(clan);
|
||||
player.setPledgeClass(L2ClanMember.calculatePledgeClass(player));
|
||||
player.setClanPrivileges(new EnumIntBitmask<>(ClanPrivilege.class, true));
|
||||
|
||||
_clans.put(Integer.valueOf(clan.getId()), clan);
|
||||
|
||||
// should be update packet only
|
||||
player.sendPacket(new PledgeShowInfoUpdate(clan));
|
||||
player.sendPacket(new PledgeShowMemberListAll(clan));
|
||||
player.sendPacket(new PledgeShowMemberListUpdate(player));
|
||||
player.sendPacket(SystemMessageId.YOUR_CLAN_HAS_BEEN_CREATED);
|
||||
player.broadcastUserInfo(UserInfoType.RELATION, UserInfoType.CLAN);
|
||||
|
||||
// Notify to scripts
|
||||
EventDispatcher.getInstance().notifyEventAsync(new OnPlayerClanCreate(player, clan));
|
||||
return clan;
|
||||
}
|
||||
|
||||
public synchronized void destroyClan(int clanId)
|
||||
{
|
||||
final L2Clan clan = getClan(clanId);
|
||||
if (clan == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
clan.broadcastToOnlineMembers(SystemMessage.getSystemMessage(SystemMessageId.CLAN_HAS_DISPERSED));
|
||||
final int castleId = clan.getCastleId();
|
||||
if (castleId == 0)
|
||||
{
|
||||
for (Siege siege : SiegeManager.getInstance().getSieges())
|
||||
{
|
||||
siege.removeSiegeClan(clan);
|
||||
}
|
||||
}
|
||||
|
||||
final int fortId = clan.getFortId();
|
||||
if (fortId == 0)
|
||||
{
|
||||
for (FortSiege siege : FortSiegeManager.getInstance().getSieges())
|
||||
{
|
||||
siege.removeAttacker(clan);
|
||||
}
|
||||
}
|
||||
|
||||
final int hallId = clan.getHideoutId();
|
||||
if (hallId == 0)
|
||||
{
|
||||
for (SiegableHall hall : CHSiegeManager.getInstance().getConquerableHalls().values())
|
||||
{
|
||||
hall.removeAttacker(clan);
|
||||
}
|
||||
}
|
||||
|
||||
final Auction auction = ClanHallAuctionManager.getInstance().getAuction(clan.getAuctionBiddedAt());
|
||||
if (auction != null)
|
||||
{
|
||||
auction.cancelBid(clan.getId());
|
||||
}
|
||||
|
||||
final L2ClanMember leaderMember = clan.getLeader();
|
||||
if (leaderMember == null)
|
||||
{
|
||||
clan.getWarehouse().destroyAllItems("ClanRemove", null, null);
|
||||
}
|
||||
else
|
||||
{
|
||||
clan.getWarehouse().destroyAllItems("ClanRemove", clan.getLeader().getPlayerInstance(), null);
|
||||
}
|
||||
|
||||
for (L2ClanMember member : clan.getMembers())
|
||||
{
|
||||
clan.removeClanMember(member.getObjectId(), 0);
|
||||
}
|
||||
|
||||
_clans.remove(clanId);
|
||||
IdFactory.getInstance().releaseId(clanId);
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection())
|
||||
{
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM clan_data WHERE clan_id=?"))
|
||||
{
|
||||
ps.setInt(1, clanId);
|
||||
ps.execute();
|
||||
}
|
||||
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM clan_privs WHERE clan_id=?"))
|
||||
{
|
||||
ps.setInt(1, clanId);
|
||||
ps.execute();
|
||||
}
|
||||
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM clan_skills WHERE clan_id=?"))
|
||||
{
|
||||
ps.setInt(1, clanId);
|
||||
ps.execute();
|
||||
}
|
||||
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM clan_subpledges WHERE clan_id=?"))
|
||||
{
|
||||
ps.setInt(1, clanId);
|
||||
ps.execute();
|
||||
}
|
||||
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM clan_wars WHERE clan1=? OR clan2=?"))
|
||||
{
|
||||
ps.setInt(1, clanId);
|
||||
ps.setInt(2, clanId);
|
||||
ps.execute();
|
||||
}
|
||||
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM clan_notices WHERE clan_id=?"))
|
||||
{
|
||||
ps.setInt(1, clanId);
|
||||
ps.execute();
|
||||
}
|
||||
|
||||
if (castleId != 0)
|
||||
{
|
||||
try (PreparedStatement ps = con.prepareStatement("UPDATE castle SET taxPercent = 0 WHERE id = ?"))
|
||||
{
|
||||
ps.setInt(1, castleId);
|
||||
ps.execute();
|
||||
}
|
||||
}
|
||||
|
||||
if (fortId != 0)
|
||||
{
|
||||
final Fort fort = FortManager.getInstance().getFortById(fortId);
|
||||
if (fort != null)
|
||||
{
|
||||
final L2Clan owner = fort.getOwnerClan();
|
||||
if (clan == owner)
|
||||
{
|
||||
fort.removeOwner(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (hallId != 0)
|
||||
{
|
||||
final SiegableHall hall = CHSiegeManager.getInstance().getSiegableHall(hallId);
|
||||
if ((hall != null) && (hall.getOwnerId() == clanId))
|
||||
{
|
||||
hall.free();
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
_log.log(Level.SEVERE, getClass().getSimpleName() + ": Error removing clan from DB.", e);
|
||||
}
|
||||
|
||||
// Notify to scripts
|
||||
EventDispatcher.getInstance().notifyEventAsync(new OnPlayerClanDestroy(leaderMember, clan));
|
||||
}
|
||||
|
||||
public void scheduleRemoveClan(final int clanId)
|
||||
{
|
||||
ThreadPoolManager.getInstance().scheduleGeneral(() ->
|
||||
{
|
||||
if (getClan(clanId) == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (getClan(clanId).getDissolvingExpiryTime() != 0)
|
||||
{
|
||||
destroyClan(clanId);
|
||||
}
|
||||
}, Math.max(getClan(clanId).getDissolvingExpiryTime() - System.currentTimeMillis(), 300000));
|
||||
}
|
||||
|
||||
public boolean isAllyExists(String allyName)
|
||||
{
|
||||
for (L2Clan clan : getClans())
|
||||
{
|
||||
if ((clan.getAllyName() != null) && clan.getAllyName().equalsIgnoreCase(allyName))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void storeclanswars(int clanId1, int clanId2)
|
||||
{
|
||||
final L2Clan clan1 = getClan(clanId1);
|
||||
final L2Clan clan2 = getClan(clanId2);
|
||||
|
||||
EventDispatcher.getInstance().notifyEventAsync(new OnClanWarStart(clan1, clan2));
|
||||
|
||||
clan1.setEnemyClan(clan2);
|
||||
clan2.setAttackerClan(clan1);
|
||||
clan1.broadcastClanStatus();
|
||||
clan2.broadcastClanStatus();
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("REPLACE INTO clan_wars (clan1, clan2, wantspeace1, wantspeace2) VALUES(?,?,?,?)"))
|
||||
{
|
||||
ps.setInt(1, clanId1);
|
||||
ps.setInt(2, clanId2);
|
||||
ps.setInt(3, 0);
|
||||
ps.setInt(4, 0);
|
||||
ps.execute();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
_log.log(Level.SEVERE, getClass().getSimpleName() + ": Error storing clan wars data.", e);
|
||||
}
|
||||
|
||||
// SystemMessage msg =
|
||||
// SystemMessage.getSystemMessage(SystemMessageId.A_CLAN_WAR_WITH_CLAN_S1_HAS_STARTED_THE_CLAN_THAT_CANCELS_THE_WAR_FIRST_WILL_LOSE_5_000_CLAN_REPUTATION_ANY_CLAN_THAT_CANCELS_THE_WAR_WILL_BE_UNABLE_TO_DECLARE_A_WAR_FOR_1_WEEK_IF_YOUR_CLAN_MEMBER_GETS_KILLED_BY_THE_OTHER_CLAN_XP_DECREASES_BY_1_4_OF_THE_AMOUNT_THAT_DECREASES_IN_THE_HUNTING_GROUND);
|
||||
//
|
||||
SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.YOU_HAVE_DECLARED_A_CLAN_WAR_WITH_S1);
|
||||
msg.addString(clan2.getName());
|
||||
clan1.broadcastToOnlineMembers(msg);
|
||||
// msg =
|
||||
// SystemMessage.getSystemMessage(SystemMessageId.A_CLAN_WAR_WITH_CLAN_S1_HAS_STARTED_THE_CLAN_THAT_CANCELS_THE_WAR_FIRST_WILL_LOSE_5_000_CLAN_REPUTATION_ANY_CLAN_THAT_CANCELS_THE_WAR_WILL_BE_UNABLE_TO_DECLARE_A_WAR_FOR_1_WEEK_IF_YOUR_CLAN_MEMBER_GETS_KILLED_BY_THE_OTHER_CLAN_XP_DECREASES_BY_1_4_OF_THE_AMOUNT_THAT_DECREASES_IN_THE_HUNTING_GROUND);
|
||||
// msg.addString(clan1.getName());
|
||||
// clan2.broadcastToOnlineMembers(msg);
|
||||
// clan1 declared clan war.
|
||||
msg = SystemMessage.getSystemMessage(SystemMessageId.S1_HAS_DECLARED_A_CLAN_WAR_THE_WAR_WILL_AUTOMATICALLY_START_IF_YOU_KILL_S1_CLAN_MEMBERS_5_TIMES_WITHIN_A_WEEK);
|
||||
msg.addString(clan1.getName());
|
||||
clan2.broadcastToOnlineMembers(msg);
|
||||
}
|
||||
|
||||
public void deleteclanswars(int clanId1, int clanId2)
|
||||
{
|
||||
final L2Clan clan1 = getClan(clanId1);
|
||||
final L2Clan clan2 = getClan(clanId2);
|
||||
|
||||
EventDispatcher.getInstance().notifyEventAsync(new OnClanWarFinish(clan1, clan2));
|
||||
|
||||
clan1.deleteEnemyClan(clan2);
|
||||
clan2.deleteAttackerClan(clan1);
|
||||
clan1.broadcastClanStatus();
|
||||
clan2.broadcastClanStatus();
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("DELETE FROM clan_wars WHERE clan1=? AND clan2=?"))
|
||||
{
|
||||
ps.setInt(1, clanId1);
|
||||
ps.setInt(2, clanId2);
|
||||
ps.execute();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
_log.log(Level.SEVERE, getClass().getSimpleName() + ": Error removing clan wars data.", e);
|
||||
}
|
||||
|
||||
// SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.WAR_WITH_THE_S1_CLAN_HAS_ENDED);
|
||||
SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.THE_WAR_AGAINST_S1_CLAN_HAS_BEEN_STOPPED);
|
||||
msg.addString(clan2.getName());
|
||||
clan1.broadcastToOnlineMembers(msg);
|
||||
msg = SystemMessage.getSystemMessage(SystemMessageId.THE_CLAN_S1_HAS_DECIDED_TO_STOP_THE_WAR);
|
||||
msg.addString(clan1.getName());
|
||||
clan2.broadcastToOnlineMembers(msg);
|
||||
}
|
||||
|
||||
public void checkSurrender(L2Clan clan1, L2Clan clan2)
|
||||
{
|
||||
int count = 0;
|
||||
for (L2ClanMember player : clan1.getMembers())
|
||||
{
|
||||
if ((player != null) && (player.getPlayerInstance().getWantsPeace() == 1))
|
||||
{
|
||||
count++;
|
||||
}
|
||||
}
|
||||
if (count == (clan1.getMembers().size() - 1))
|
||||
{
|
||||
clan1.deleteEnemyClan(clan2);
|
||||
clan2.deleteEnemyClan(clan1);
|
||||
deleteclanswars(clan1.getId(), clan2.getId());
|
||||
}
|
||||
}
|
||||
|
||||
private void restorewars()
|
||||
{
|
||||
L2Clan clan1, clan2;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement statement = con.createStatement();
|
||||
ResultSet rset = statement.executeQuery("SELECT clan1, clan2 FROM clan_wars"))
|
||||
{
|
||||
while (rset.next())
|
||||
{
|
||||
clan1 = getClan(rset.getInt("clan1"));
|
||||
clan2 = getClan(rset.getInt("clan2"));
|
||||
if ((clan1 != null) && (clan2 != null))
|
||||
{
|
||||
clan1.setEnemyClan(rset.getInt("clan2"));
|
||||
clan2.setAttackerClan(rset.getInt("clan1"));
|
||||
}
|
||||
else
|
||||
{
|
||||
_log.log(Level.WARNING, getClass().getSimpleName() + ": restorewars one of clans is null clan1:" + clan1 + " clan2:" + clan2);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
_log.log(Level.SEVERE, getClass().getSimpleName() + ": Error restoring clan wars data.", e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for nonexistent alliances
|
||||
*/
|
||||
private void allianceCheck()
|
||||
{
|
||||
for (L2Clan clan : _clans.values())
|
||||
{
|
||||
final int allyId = clan.getAllyId();
|
||||
if ((allyId != 0) && (clan.getId() != allyId))
|
||||
{
|
||||
if (!_clans.containsKey(allyId))
|
||||
{
|
||||
clan.setAllyId(0);
|
||||
clan.setAllyName(null);
|
||||
clan.changeAllyCrest(0, true);
|
||||
clan.updateClanInDB();
|
||||
_log.info(getClass().getSimpleName() + ": Removed alliance from clan: " + clan);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public List<L2Clan> getClanAllies(int allianceId)
|
||||
{
|
||||
final List<L2Clan> clanAllies = new ArrayList<>();
|
||||
if (allianceId != 0)
|
||||
{
|
||||
for (L2Clan clan : _clans.values())
|
||||
{
|
||||
if ((clan != null) && (clan.getAllyId() == allianceId))
|
||||
{
|
||||
clanAllies.add(clan);
|
||||
}
|
||||
}
|
||||
}
|
||||
return clanAllies;
|
||||
}
|
||||
|
||||
public void storeClanScore()
|
||||
{
|
||||
for (L2Clan clan : _clans.values())
|
||||
{
|
||||
clan.updateClanScoreInDB();
|
||||
}
|
||||
}
|
||||
|
||||
public static ClanTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final ClanTable _instance = new ClanTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,228 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.HashSet;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.model.L2Clan;
|
||||
import com.l2jmobius.gameserver.model.L2Crest;
|
||||
import com.l2jmobius.gameserver.model.L2Crest.CrestType;
|
||||
|
||||
/**
|
||||
* Loads and saves crests from database.
|
||||
* @author NosBit
|
||||
*/
|
||||
public final class CrestTable
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(CrestTable.class.getName());
|
||||
|
||||
private final Map<Integer, L2Crest> _crests = new ConcurrentHashMap<>();
|
||||
private final AtomicInteger _nextId = new AtomicInteger(1);
|
||||
|
||||
protected CrestTable()
|
||||
{
|
||||
load();
|
||||
}
|
||||
|
||||
public synchronized void load()
|
||||
{
|
||||
_crests.clear();
|
||||
final Set<Integer> crestsInUse = new HashSet<>();
|
||||
for (L2Clan clan : ClanTable.getInstance().getClans())
|
||||
{
|
||||
if (clan.getCrestId() != 0)
|
||||
{
|
||||
crestsInUse.add(clan.getCrestId());
|
||||
}
|
||||
|
||||
if (clan.getCrestLargeId() != 0)
|
||||
{
|
||||
crestsInUse.add(clan.getCrestLargeId());
|
||||
}
|
||||
|
||||
if (clan.getAllyCrestId() != 0)
|
||||
{
|
||||
crestsInUse.add(clan.getAllyCrestId());
|
||||
}
|
||||
}
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement statement = con.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
|
||||
ResultSet rs = statement.executeQuery("SELECT `crest_id`, `data`, `type` FROM `crests` ORDER BY `crest_id` DESC"))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
final int id = rs.getInt("crest_id");
|
||||
|
||||
if (_nextId.get() <= id)
|
||||
{
|
||||
_nextId.set(id + 1);
|
||||
}
|
||||
|
||||
// delete all unused crests except the last one we dont want to reuse
|
||||
// a crest id because client will display wrong crest if its reused
|
||||
if (!crestsInUse.contains(id) && (id != (_nextId.get() - 1)))
|
||||
{
|
||||
rs.deleteRow();
|
||||
continue;
|
||||
}
|
||||
|
||||
final byte[] data = rs.getBytes("data");
|
||||
final CrestType crestType = CrestType.getById(rs.getInt("type"));
|
||||
if (crestType != null)
|
||||
{
|
||||
_crests.put(id, new L2Crest(id, data, crestType));
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGGER.warning("Unknown crest type found in database. Type:" + rs.getInt("type"));
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "There was an error while loading crests from database:", e);
|
||||
}
|
||||
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loaded " + _crests.size() + " Crests.");
|
||||
|
||||
for (L2Clan clan : ClanTable.getInstance().getClans())
|
||||
{
|
||||
if (clan.getCrestId() != 0)
|
||||
{
|
||||
if (getCrest(clan.getCrestId()) == null)
|
||||
{
|
||||
LOGGER.info("Removing non-existent crest for clan " + clan.getName() + " [" + clan.getId() + "], crestId:" + clan.getCrestId());
|
||||
clan.setCrestId(0);
|
||||
clan.changeClanCrest(0);
|
||||
}
|
||||
}
|
||||
|
||||
if (clan.getCrestLargeId() != 0)
|
||||
{
|
||||
if (getCrest(clan.getCrestLargeId()) == null)
|
||||
{
|
||||
LOGGER.info("Removing non-existent large crest for clan " + clan.getName() + " [" + clan.getId() + "], crestLargeId:" + clan.getCrestLargeId());
|
||||
clan.setCrestLargeId(0);
|
||||
clan.changeLargeCrest(0);
|
||||
}
|
||||
}
|
||||
|
||||
if (clan.getAllyCrestId() != 0)
|
||||
{
|
||||
if (getCrest(clan.getAllyCrestId()) == null)
|
||||
{
|
||||
LOGGER.info("Removing non-existent ally crest for clan " + clan.getName() + " [" + clan.getId() + "], allyCrestId:" + clan.getAllyCrestId());
|
||||
clan.setAllyCrestId(0);
|
||||
clan.changeAllyCrest(0, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param crestId The crest id
|
||||
* @return {@code L2Crest} if crest is found, {@code null} if crest was not found.
|
||||
*/
|
||||
public L2Crest getCrest(int crestId)
|
||||
{
|
||||
return _crests.get(crestId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a {@code L2Crest} object and inserts it in database and cache.
|
||||
* @param data
|
||||
* @param crestType
|
||||
* @return {@code L2Crest} on success, {@code null} on failure.
|
||||
*/
|
||||
public L2Crest createCrest(byte[] data, CrestType crestType)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement statement = con.prepareStatement("INSERT INTO `crests`(`crest_id`, `data`, `type`) VALUES(?, ?, ?)"))
|
||||
{
|
||||
final L2Crest crest = new L2Crest(getNextId(), data, crestType);
|
||||
statement.setInt(1, crest.getId());
|
||||
statement.setBytes(2, crest.getData());
|
||||
statement.setInt(3, crest.getType().getId());
|
||||
statement.executeUpdate();
|
||||
_crests.put(crest.getId(), crest);
|
||||
return crest;
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "There was an error while saving crest in database:", e);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes crest from database and cache.
|
||||
* @param crestId the id of crest to be removed.
|
||||
*/
|
||||
public void removeCrest(int crestId)
|
||||
{
|
||||
_crests.remove(crestId);
|
||||
|
||||
// avoid removing last crest id we dont want to lose index...
|
||||
// because client will display wrong crest if its reused
|
||||
if (crestId == (_nextId.get() - 1))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement statement = con.prepareStatement("DELETE FROM `crests` WHERE `crest_id` = ?"))
|
||||
{
|
||||
statement.setInt(1, crestId);
|
||||
statement.executeUpdate();
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "There was an error while deleting crest from database:", e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The next crest id.
|
||||
*/
|
||||
public int getNextId()
|
||||
{
|
||||
return _nextId.getAndIncrement();
|
||||
}
|
||||
|
||||
public static CrestTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final CrestTable _instance = new CrestTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,203 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
import com.l2jmobius.gameserver.model.holders.SkillHolder;
|
||||
|
||||
public class NpcBufferTable
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(NpcBufferTable.class.getName());
|
||||
|
||||
private final Map<Integer, NpcBufferSkills> _buffers = new HashMap<>();
|
||||
|
||||
public static class NpcBufferData
|
||||
{
|
||||
private final SkillHolder _skill;
|
||||
private final ItemHolder _fee;
|
||||
|
||||
protected NpcBufferData(int skillId, int skillLevel, int feeId, int feeAmount)
|
||||
{
|
||||
_skill = new SkillHolder(skillId, skillLevel);
|
||||
_fee = new ItemHolder(feeId, feeAmount);
|
||||
}
|
||||
|
||||
public SkillHolder getSkill()
|
||||
{
|
||||
return _skill;
|
||||
}
|
||||
|
||||
public ItemHolder getFee()
|
||||
{
|
||||
return _fee;
|
||||
}
|
||||
}
|
||||
|
||||
private static class NpcBufferSkills
|
||||
{
|
||||
private final int _npcId;
|
||||
private final Map<Integer, NpcBufferData> _skills = new HashMap<>();
|
||||
|
||||
protected NpcBufferSkills(int npcId)
|
||||
{
|
||||
_npcId = npcId;
|
||||
}
|
||||
|
||||
public void addSkill(int skillId, int skillLevel, int skillFeeId, int skillFeeAmount, int buffGroup)
|
||||
{
|
||||
_skills.put(buffGroup, new NpcBufferData(skillId, skillLevel, skillFeeId, skillFeeAmount));
|
||||
}
|
||||
|
||||
public NpcBufferData getSkillGroupInfo(int buffGroup)
|
||||
{
|
||||
return _skills.get(buffGroup);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public int getNpcId()
|
||||
{
|
||||
return _npcId;
|
||||
}
|
||||
}
|
||||
|
||||
protected NpcBufferTable()
|
||||
{
|
||||
int skillCount = 0;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rset = s.executeQuery("SELECT `npc_id`,`skill_id`,`skill_level`,`skill_fee_id`,`skill_fee_amount`,`buff_group` FROM `npc_buffer` ORDER BY `npc_id` ASC"))
|
||||
{
|
||||
int lastNpcId = 0;
|
||||
NpcBufferSkills skills = null;
|
||||
|
||||
while (rset.next())
|
||||
{
|
||||
final int npcId = rset.getInt("npc_id");
|
||||
final int skillId = rset.getInt("skill_id");
|
||||
final int skillLevel = rset.getInt("skill_level");
|
||||
final int skillFeeId = rset.getInt("skill_fee_id");
|
||||
final int skillFeeAmount = rset.getInt("skill_fee_amount");
|
||||
final int buffGroup = rset.getInt("buff_group");
|
||||
|
||||
if (npcId != lastNpcId)
|
||||
{
|
||||
if (lastNpcId != 0)
|
||||
{
|
||||
_buffers.put(lastNpcId, skills);
|
||||
}
|
||||
|
||||
skills = new NpcBufferSkills(npcId);
|
||||
skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
|
||||
}
|
||||
else if (skills != null)
|
||||
{
|
||||
skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
|
||||
}
|
||||
|
||||
lastNpcId = npcId;
|
||||
skillCount++;
|
||||
}
|
||||
|
||||
if (lastNpcId != 0)
|
||||
{
|
||||
_buffers.put(lastNpcId, skills);
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.SEVERE, getClass().getSimpleName() + ": Error reading npc_buffer table: " + e.getMessage(), e);
|
||||
}
|
||||
|
||||
if (Config.CUSTOM_NPCBUFFER_TABLES)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rset = s.executeQuery("SELECT `npc_id`,`skill_id`,`skill_level`,`skill_fee_id`,`skill_fee_amount`,`buff_group` FROM `custom_npc_buffer` ORDER BY `npc_id` ASC"))
|
||||
{
|
||||
int lastNpcId = 0;
|
||||
NpcBufferSkills skills = null;
|
||||
while (rset.next())
|
||||
{
|
||||
final int npcId = rset.getInt("npc_id");
|
||||
final int skillId = rset.getInt("skill_id");
|
||||
final int skillLevel = rset.getInt("skill_level");
|
||||
final int skillFeeId = rset.getInt("skill_fee_id");
|
||||
final int skillFeeAmount = rset.getInt("skill_fee_amount");
|
||||
final int buffGroup = rset.getInt("buff_group");
|
||||
|
||||
if (npcId != lastNpcId)
|
||||
{
|
||||
if (lastNpcId != 0)
|
||||
{
|
||||
_buffers.put(lastNpcId, skills);
|
||||
}
|
||||
|
||||
skills = new NpcBufferSkills(npcId);
|
||||
skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
|
||||
}
|
||||
else if (skills != null)
|
||||
{
|
||||
skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
|
||||
}
|
||||
lastNpcId = npcId;
|
||||
skillCount++;
|
||||
}
|
||||
|
||||
if (lastNpcId != 0)
|
||||
{
|
||||
_buffers.put(lastNpcId, skills);
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.SEVERE, getClass().getSimpleName() + ": Error reading custom_npc_buffer table: " + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loaded " + _buffers.size() + " buffers and " + skillCount + " skills.");
|
||||
}
|
||||
|
||||
public NpcBufferData getSkillInfo(int npcId, int buffGroup)
|
||||
{
|
||||
final NpcBufferSkills skills = _buffers.get(npcId);
|
||||
if (skills != null)
|
||||
{
|
||||
return skills.getSkillGroupInfo(buffGroup);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static NpcBufferTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final NpcBufferTable _instance = new NpcBufferTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,415 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.Statement;
|
||||
import java.util.Calendar;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.LoginServerThread;
|
||||
import com.l2jmobius.gameserver.enums.PrivateStoreType;
|
||||
import com.l2jmobius.gameserver.model.L2ManufactureItem;
|
||||
import com.l2jmobius.gameserver.model.L2World;
|
||||
import com.l2jmobius.gameserver.model.TradeItem;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
|
||||
import com.l2jmobius.gameserver.network.L2GameClient;
|
||||
import com.l2jmobius.gameserver.network.L2GameClient.GameClientState;
|
||||
|
||||
public class OfflineTradersTable
|
||||
{
|
||||
private static Logger LOGGER = Logger.getLogger(OfflineTradersTable.class.getName());
|
||||
|
||||
// SQL DEFINITIONS
|
||||
private static final String SAVE_OFFLINE_STATUS = "INSERT INTO character_offline_trade (`charId`,`time`,`type`,`title`) VALUES (?,?,?,?)";
|
||||
private static final String SAVE_ITEMS = "INSERT INTO character_offline_trade_items (`charId`,`item`,`count`,`price`) VALUES (?,?,?,?)";
|
||||
private static final String CLEAR_OFFLINE_TABLE = "DELETE FROM character_offline_trade";
|
||||
private static final String CLEAR_OFFLINE_TABLE_PLAYER = "DELETE FROM character_offline_trade WHERE `charId`=?";
|
||||
private static final String CLEAR_OFFLINE_TABLE_ITEMS = "DELETE FROM character_offline_trade_items";
|
||||
private static final String CLEAR_OFFLINE_TABLE_ITEMS_PLAYER = "DELETE FROM character_offline_trade_items WHERE `charId`=?";
|
||||
private static final String LOAD_OFFLINE_STATUS = "SELECT * FROM character_offline_trade";
|
||||
private static final String LOAD_OFFLINE_ITEMS = "SELECT * FROM character_offline_trade_items WHERE `charId`=?";
|
||||
|
||||
public void storeOffliners()
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement stm1 = con.prepareStatement(CLEAR_OFFLINE_TABLE);
|
||||
PreparedStatement stm2 = con.prepareStatement(CLEAR_OFFLINE_TABLE_ITEMS);
|
||||
PreparedStatement stm3 = con.prepareStatement(SAVE_OFFLINE_STATUS);
|
||||
PreparedStatement stm_items = con.prepareStatement(SAVE_ITEMS))
|
||||
{
|
||||
stm1.execute();
|
||||
stm2.execute();
|
||||
con.setAutoCommit(false); // avoid halfway done
|
||||
|
||||
for (L2PcInstance pc : L2World.getInstance().getPlayers())
|
||||
{
|
||||
try
|
||||
{
|
||||
if ((pc.getPrivateStoreType() != PrivateStoreType.NONE) && pc.isInOfflineMode())
|
||||
{
|
||||
stm3.setInt(1, pc.getObjectId()); // Char Id
|
||||
stm3.setLong(2, pc.getOfflineStartTime());
|
||||
stm3.setInt(3, pc.getPrivateStoreType().getId()); // store type
|
||||
String title = null;
|
||||
|
||||
switch (pc.getPrivateStoreType())
|
||||
{
|
||||
case BUY:
|
||||
{
|
||||
if (!Config.OFFLINE_TRADE_ENABLE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
title = pc.getBuyList().getTitle();
|
||||
for (TradeItem i : pc.getBuyList().getItems())
|
||||
{
|
||||
stm_items.setInt(1, pc.getObjectId());
|
||||
stm_items.setInt(2, i.getItem().getId());
|
||||
stm_items.setLong(3, i.getCount());
|
||||
stm_items.setLong(4, i.getPrice());
|
||||
stm_items.executeUpdate();
|
||||
stm_items.clearParameters();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SELL:
|
||||
case PACKAGE_SELL:
|
||||
{
|
||||
if (!Config.OFFLINE_TRADE_ENABLE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
title = pc.getSellList().getTitle();
|
||||
for (TradeItem i : pc.getSellList().getItems())
|
||||
{
|
||||
stm_items.setInt(1, pc.getObjectId());
|
||||
stm_items.setInt(2, i.getObjectId());
|
||||
stm_items.setLong(3, i.getCount());
|
||||
stm_items.setLong(4, i.getPrice());
|
||||
stm_items.executeUpdate();
|
||||
stm_items.clearParameters();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MANUFACTURE:
|
||||
{
|
||||
if (!Config.OFFLINE_CRAFT_ENABLE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
title = pc.getStoreName();
|
||||
for (L2ManufactureItem i : pc.getManufactureItems().values())
|
||||
{
|
||||
stm_items.setInt(1, pc.getObjectId());
|
||||
stm_items.setInt(2, i.getRecipeId());
|
||||
stm_items.setLong(3, 0);
|
||||
stm_items.setLong(4, i.getCost());
|
||||
stm_items.executeUpdate();
|
||||
stm_items.clearParameters();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
stm3.setString(4, title);
|
||||
stm3.executeUpdate();
|
||||
stm3.clearParameters();
|
||||
con.commit(); // flush
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Error while saving offline trader: " + pc.getObjectId() + " " + e, e);
|
||||
}
|
||||
}
|
||||
LOGGER.info(getClass().getSimpleName() + ": Offline traders stored.");
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Error while saving offline traders: " + e, e);
|
||||
}
|
||||
}
|
||||
|
||||
public void restoreOfflineTraders()
|
||||
{
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loading offline traders...");
|
||||
int nTraders = 0;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement stm = con.createStatement();
|
||||
ResultSet rs = stm.executeQuery(LOAD_OFFLINE_STATUS))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
final long time = rs.getLong("time");
|
||||
if (Config.OFFLINE_MAX_DAYS > 0)
|
||||
{
|
||||
final Calendar cal = Calendar.getInstance();
|
||||
cal.setTimeInMillis(time);
|
||||
cal.add(Calendar.DAY_OF_YEAR, Config.OFFLINE_MAX_DAYS);
|
||||
if (cal.getTimeInMillis() <= System.currentTimeMillis())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
final PrivateStoreType type = PrivateStoreType.findById(rs.getInt("type"));
|
||||
if (type == null)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": PrivateStoreType with id " + rs.getInt("type") + " could not be found.");
|
||||
continue;
|
||||
}
|
||||
|
||||
if (type == PrivateStoreType.NONE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
L2PcInstance player = null;
|
||||
|
||||
try
|
||||
{
|
||||
final L2GameClient client = new L2GameClient(null);
|
||||
client.setDetached(true);
|
||||
player = L2PcInstance.load(rs.getInt("charId"));
|
||||
client.setActiveChar(player);
|
||||
player.setOnlineStatus(true, false);
|
||||
client.setAccountName(player.getAccountNamePlayer());
|
||||
L2World.getInstance().addPlayerToWorld(player);
|
||||
client.setState(GameClientState.IN_GAME);
|
||||
player.setClient(client);
|
||||
player.setOfflineStartTime(time);
|
||||
player.spawnMe(player.getX(), player.getY(), player.getZ());
|
||||
LoginServerThread.getInstance().addGameServerLogin(player.getAccountName(), client);
|
||||
try (PreparedStatement stm_items = con.prepareStatement(LOAD_OFFLINE_ITEMS))
|
||||
{
|
||||
stm_items.setInt(1, player.getObjectId());
|
||||
try (ResultSet items = stm_items.executeQuery())
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case BUY:
|
||||
{
|
||||
while (items.next())
|
||||
{
|
||||
if (player.getBuyList().addItemByItemId(items.getInt(2), items.getLong(3), items.getLong(4), 0, 0, 0, new int[]
|
||||
{
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
}, 0) == null)
|
||||
{
|
||||
continue;
|
||||
// throw new NullPointerException();
|
||||
}
|
||||
}
|
||||
player.getBuyList().setTitle(rs.getString("title"));
|
||||
break;
|
||||
}
|
||||
case SELL:
|
||||
case PACKAGE_SELL:
|
||||
{
|
||||
while (items.next())
|
||||
{
|
||||
if (player.getSellList().addItem(items.getInt(2), items.getLong(3), items.getLong(4)) == null)
|
||||
{
|
||||
continue;
|
||||
// throw new NullPointerException();
|
||||
}
|
||||
}
|
||||
player.getSellList().setTitle(rs.getString("title"));
|
||||
player.getSellList().setPackaged(type == PrivateStoreType.PACKAGE_SELL);
|
||||
break;
|
||||
}
|
||||
case MANUFACTURE:
|
||||
{
|
||||
while (items.next())
|
||||
{
|
||||
player.getManufactureItems().put(items.getInt(2), new L2ManufactureItem(items.getInt(2), items.getLong(4)));
|
||||
}
|
||||
player.setStoreName(rs.getString("title"));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
player.sitDown();
|
||||
if (Config.OFFLINE_SET_NAME_COLOR)
|
||||
{
|
||||
player.getAppearance().setNameColor(Config.OFFLINE_NAME_COLOR);
|
||||
}
|
||||
player.setPrivateStoreType(type);
|
||||
player.setOnlineStatus(true, true);
|
||||
player.restoreEffects();
|
||||
player.broadcastUserInfo();
|
||||
nTraders++;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Error loading trader: " + player, e);
|
||||
if (player != null)
|
||||
{
|
||||
player.deleteMe();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loaded: " + nTraders + " offline trader(s)");
|
||||
|
||||
if (!Config.STORE_OFFLINE_TRADE_IN_REALTIME)
|
||||
{
|
||||
try (Statement stm1 = con.createStatement())
|
||||
{
|
||||
stm1.execute(CLEAR_OFFLINE_TABLE);
|
||||
stm1.execute(CLEAR_OFFLINE_TABLE_ITEMS);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Error while loading offline traders: ", e);
|
||||
}
|
||||
}
|
||||
|
||||
public static synchronized void onTransaction(L2PcInstance trader, boolean finished, boolean firstCall)
|
||||
{
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement stm1 = con.prepareStatement(CLEAR_OFFLINE_TABLE_ITEMS_PLAYER);
|
||||
PreparedStatement stm2 = con.prepareStatement(CLEAR_OFFLINE_TABLE_PLAYER);
|
||||
PreparedStatement stm3 = con.prepareStatement(SAVE_ITEMS);
|
||||
PreparedStatement stm4 = con.prepareStatement(SAVE_OFFLINE_STATUS))
|
||||
{
|
||||
String title = null;
|
||||
|
||||
stm1.setInt(1, trader.getObjectId()); // Char Id
|
||||
stm1.execute();
|
||||
stm1.close();
|
||||
|
||||
// Trade is done - clear info
|
||||
if (finished)
|
||||
{
|
||||
stm2.setInt(1, trader.getObjectId()); // Char Id
|
||||
stm2.execute();
|
||||
stm2.close();
|
||||
}
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
if ((trader.getClient() == null) || trader.getClient().isDetached())
|
||||
{
|
||||
switch (trader.getPrivateStoreType())
|
||||
{
|
||||
case BUY:
|
||||
{
|
||||
if (firstCall)
|
||||
{
|
||||
title = trader.getBuyList().getTitle();
|
||||
}
|
||||
for (TradeItem i : trader.getBuyList().getItems())
|
||||
{
|
||||
stm3.setInt(1, trader.getObjectId());
|
||||
stm3.setInt(2, i.getItem().getId());
|
||||
stm3.setLong(3, i.getCount());
|
||||
stm3.setLong(4, i.getPrice());
|
||||
stm3.executeUpdate();
|
||||
stm3.clearParameters();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SELL:
|
||||
case PACKAGE_SELL:
|
||||
{
|
||||
if (firstCall)
|
||||
{
|
||||
title = trader.getSellList().getTitle();
|
||||
}
|
||||
for (TradeItem i : trader.getSellList().getItems())
|
||||
{
|
||||
stm3.setInt(1, trader.getObjectId());
|
||||
stm3.setInt(2, i.getObjectId());
|
||||
stm3.setLong(3, i.getCount());
|
||||
stm3.setLong(4, i.getPrice());
|
||||
stm3.executeUpdate();
|
||||
stm3.clearParameters();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MANUFACTURE:
|
||||
{
|
||||
if (firstCall)
|
||||
{
|
||||
title = trader.getStoreName();
|
||||
}
|
||||
for (L2ManufactureItem i : trader.getManufactureItems().values())
|
||||
{
|
||||
stm3.setInt(1, trader.getObjectId());
|
||||
stm3.setInt(2, i.getRecipeId());
|
||||
stm3.setLong(3, 0);
|
||||
stm3.setLong(4, i.getCost());
|
||||
stm3.executeUpdate();
|
||||
stm3.clearParameters();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
stm3.close();
|
||||
if (firstCall)
|
||||
{
|
||||
stm4.setInt(1, trader.getObjectId()); // Char Id
|
||||
stm4.setLong(2, trader.getOfflineStartTime());
|
||||
stm4.setInt(3, trader.getPrivateStoreType().getId()); // store type
|
||||
stm4.setString(4, title);
|
||||
stm4.executeUpdate();
|
||||
stm4.clearParameters();
|
||||
stm4.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "OfflineTradersTable[storeTradeItems()]: Error while saving offline trader: " + trader.getObjectId() + " " + e, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "OfflineTradersTable[storeTradeItems()]: Error while saving offline traders: " + e, e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the single instance of OfflineTradersTable.
|
||||
* @return single instance of OfflineTradersTable
|
||||
*/
|
||||
public static OfflineTradersTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final OfflineTradersTable _instance = new OfflineTradersTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,115 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.regex.PatternSyntaxException;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.data.xml.impl.PetDataTable;
|
||||
|
||||
public class PetNameTable
|
||||
{
|
||||
private static Logger LOGGER = Logger.getLogger(PetNameTable.class.getName());
|
||||
|
||||
public static PetNameTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
public boolean doesPetNameExist(String name, int petNpcId)
|
||||
{
|
||||
boolean result = true;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT name FROM pets p, items i WHERE p.item_obj_id = i.object_id AND name=? AND i.item_id IN (?)"))
|
||||
{
|
||||
ps.setString(1, name);
|
||||
final StringBuilder cond = new StringBuilder();
|
||||
if (!cond.toString().isEmpty())
|
||||
{
|
||||
cond.append(", ");
|
||||
}
|
||||
|
||||
cond.append(PetDataTable.getInstance().getPetItemsByNpc(petNpcId));
|
||||
ps.setString(2, cond.toString());
|
||||
try (ResultSet rs = ps.executeQuery())
|
||||
{
|
||||
result = rs.next();
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Could not check existing petname:" + e.getMessage(), e);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public boolean isValidPetName(String name)
|
||||
{
|
||||
boolean result = true;
|
||||
|
||||
if (!isAlphaNumeric(name))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
Pattern pattern;
|
||||
try
|
||||
{
|
||||
pattern = Pattern.compile(Config.PET_NAME_TEMPLATE);
|
||||
}
|
||||
catch (PatternSyntaxException e) // case of illegal pattern
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Pet name pattern of config is wrong!");
|
||||
pattern = Pattern.compile(".*");
|
||||
}
|
||||
final Matcher regexp = pattern.matcher(name);
|
||||
if (!regexp.matches())
|
||||
{
|
||||
result = false;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private boolean isAlphaNumeric(String text)
|
||||
{
|
||||
boolean result = true;
|
||||
final char[] chars = text.toCharArray();
|
||||
for (int i = 0; i < chars.length; i++)
|
||||
{
|
||||
if (!Character.isLetterOrDigit(chars[i]))
|
||||
{
|
||||
result = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final PetNameTable _instance = new PetNameTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,184 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
|
||||
import com.l2jmobius.gameserver.model.actor.L2Summon;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2PetInstance;
|
||||
import com.l2jmobius.gameserver.model.actor.instance.L2ServitorInstance;
|
||||
import com.l2jmobius.gameserver.model.skills.Skill;
|
||||
|
||||
/**
|
||||
* @author Nyaran
|
||||
*/
|
||||
public class SummonEffectsTable
|
||||
{
|
||||
/** Servitors **/
|
||||
// Map tree
|
||||
// -> key: charObjectId, value: classIndex Map
|
||||
// --> key: classIndex, value: servitors Map
|
||||
// ---> key: servitorSkillId, value: Effects list
|
||||
private final Map<Integer, Map<Integer, Map<Integer, List<SummonEffect>>>> _servitorEffects = new HashMap<>();
|
||||
|
||||
private Map<Integer, List<SummonEffect>> getServitorEffects(L2PcInstance owner)
|
||||
{
|
||||
final Map<Integer, Map<Integer, List<SummonEffect>>> servitorMap = _servitorEffects.get(owner.getObjectId());
|
||||
if (servitorMap == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return servitorMap.get(owner.getClassIndex());
|
||||
}
|
||||
|
||||
private List<SummonEffect> getServitorEffects(L2PcInstance owner, int referenceSkill)
|
||||
{
|
||||
return containsOwner(owner) ? getServitorEffects(owner).get(referenceSkill) : null;
|
||||
}
|
||||
|
||||
private boolean containsOwner(L2PcInstance owner)
|
||||
{
|
||||
return _servitorEffects.getOrDefault(owner.getObjectId(), Collections.emptyMap()).containsKey(owner.getClassIndex());
|
||||
}
|
||||
|
||||
private void removeEffects(List<SummonEffect> effects, int skillId)
|
||||
{
|
||||
if ((effects != null) && !effects.isEmpty())
|
||||
{
|
||||
for (SummonEffect effect : effects)
|
||||
{
|
||||
final Skill skill = effect.getSkill();
|
||||
if ((skill != null) && (skill.getId() == skillId))
|
||||
{
|
||||
effects.remove(effect);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void applyEffects(L2Summon summon, List<SummonEffect> summonEffects)
|
||||
{
|
||||
if (summonEffects == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
for (SummonEffect se : summonEffects)
|
||||
{
|
||||
if (se != null)
|
||||
{
|
||||
se.getSkill().applyEffects(summon, summon, false, se.getEffectCurTime());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public boolean containsSkill(L2PcInstance owner, int referenceSkill)
|
||||
{
|
||||
return containsOwner(owner) && getServitorEffects(owner).containsKey(referenceSkill);
|
||||
}
|
||||
|
||||
public void clearServitorEffects(L2PcInstance owner, int referenceSkill)
|
||||
{
|
||||
if (containsOwner(owner))
|
||||
{
|
||||
getServitorEffects(owner).getOrDefault(referenceSkill, Collections.emptyList()).clear();
|
||||
}
|
||||
}
|
||||
|
||||
public void addServitorEffect(L2PcInstance owner, int referenceSkill, Skill skill, int effectCurTime)
|
||||
{
|
||||
_servitorEffects.putIfAbsent(owner.getObjectId(), new HashMap<Integer, Map<Integer, List<SummonEffect>>>());
|
||||
_servitorEffects.get(owner.getObjectId()).putIfAbsent(owner.getClassIndex(), new HashMap<Integer, List<SummonEffect>>());
|
||||
getServitorEffects(owner).putIfAbsent(referenceSkill, new CopyOnWriteArrayList<SummonEffect>());
|
||||
getServitorEffects(owner).get(referenceSkill).add(new SummonEffect(skill, effectCurTime));
|
||||
}
|
||||
|
||||
public void removeServitorEffects(L2PcInstance owner, int referenceSkill, int skillId)
|
||||
{
|
||||
removeEffects(getServitorEffects(owner, referenceSkill), skillId);
|
||||
}
|
||||
|
||||
public void applyServitorEffects(L2ServitorInstance l2ServitorInstance, L2PcInstance owner, int referenceSkill)
|
||||
{
|
||||
applyEffects(l2ServitorInstance, getServitorEffects(owner, referenceSkill));
|
||||
}
|
||||
|
||||
/** Pets **/
|
||||
private final Map<Integer, List<SummonEffect>> _petEffects = new HashMap<>(); // key: petItemObjectId, value: Effects list
|
||||
|
||||
public void addPetEffect(int controlObjectId, Skill skill, int effectCurTime)
|
||||
{
|
||||
_petEffects.computeIfAbsent(controlObjectId, k -> new ArrayList<>()).add(new SummonEffect(skill, effectCurTime));
|
||||
}
|
||||
|
||||
public boolean containsPetId(int controlObjectId)
|
||||
{
|
||||
return _petEffects.containsKey(controlObjectId);
|
||||
}
|
||||
|
||||
public void applyPetEffects(L2PetInstance l2PetInstance, int controlObjectId)
|
||||
{
|
||||
applyEffects(l2PetInstance, _petEffects.get(controlObjectId));
|
||||
}
|
||||
|
||||
public void clearPetEffects(int controlObjectId)
|
||||
{
|
||||
_petEffects.getOrDefault(controlObjectId, Collections.emptyList()).clear();
|
||||
}
|
||||
|
||||
public void removePetEffects(int controlObjectId, int skillId)
|
||||
{
|
||||
removeEffects(_petEffects.get(controlObjectId), skillId);
|
||||
}
|
||||
|
||||
private class SummonEffect
|
||||
{
|
||||
Skill _skill;
|
||||
int _effectCurTime;
|
||||
|
||||
public SummonEffect(Skill skill, int effectCurTime)
|
||||
{
|
||||
_skill = skill;
|
||||
_effectCurTime = effectCurTime;
|
||||
}
|
||||
|
||||
public Skill getSkill()
|
||||
{
|
||||
return _skill;
|
||||
}
|
||||
|
||||
public int getEffectCurTime()
|
||||
{
|
||||
return _effectCurTime;
|
||||
}
|
||||
}
|
||||
|
||||
public static SummonEffectsTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final SummonEffectsTable _instance = new SummonEffectsTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,182 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.Statement;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.datatables.SkillData;
|
||||
import com.l2jmobius.gameserver.model.actor.L2Summon;
|
||||
|
||||
public class SummonSkillsTable
|
||||
{
|
||||
private static Logger LOGGER = Logger.getLogger(SummonSkillsTable.class.getName());
|
||||
private final Map<Integer, Map<Integer, L2PetSkillLearn>> _skillTrees = new HashMap<>();
|
||||
|
||||
protected SummonSkillsTable()
|
||||
{
|
||||
load();
|
||||
}
|
||||
|
||||
public void load()
|
||||
{
|
||||
_skillTrees.clear();
|
||||
int count = 0;
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery("SELECT templateId, minLvl, skillId, skillLvl FROM pets_skills"))
|
||||
{
|
||||
while (rs.next())
|
||||
{
|
||||
final int npcId = rs.getInt("templateId");
|
||||
Map<Integer, L2PetSkillLearn> skillTree = _skillTrees.get(npcId);
|
||||
if (skillTree == null)
|
||||
{
|
||||
skillTree = new HashMap<>();
|
||||
_skillTrees.put(npcId, skillTree);
|
||||
}
|
||||
|
||||
final int id = rs.getInt("skillId");
|
||||
final int lvl = rs.getInt("skillLvl");
|
||||
skillTree.put(SkillData.getSkillHashCode(id, lvl + 1), new L2PetSkillLearn(id, lvl, rs.getInt("minLvl")));
|
||||
count++;
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.SEVERE, getClass().getSimpleName() + ": Error while loading pet skill tree:", e);
|
||||
}
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loaded " + count + " skills.");
|
||||
}
|
||||
|
||||
public int getAvailableLevel(L2Summon cha, int skillId)
|
||||
{
|
||||
int lvl = 0;
|
||||
if (!_skillTrees.containsKey(cha.getId()))
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Pet id " + cha.getId() + " does not have any skills assigned.");
|
||||
return lvl;
|
||||
}
|
||||
final Collection<L2PetSkillLearn> skills = _skillTrees.get(cha.getId()).values();
|
||||
for (L2PetSkillLearn temp : skills)
|
||||
{
|
||||
if (temp.getId() != skillId)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (temp.getLevel() == 0)
|
||||
{
|
||||
if (cha.getLevel() < 70)
|
||||
{
|
||||
lvl = (cha.getLevel() / 10);
|
||||
if (lvl <= 0)
|
||||
{
|
||||
lvl = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
lvl = (7 + ((cha.getLevel() - 70) / 5));
|
||||
}
|
||||
|
||||
// formula usable for skill that have 10 or more skill levels
|
||||
final int maxLvl = SkillData.getInstance().getMaxLevel(temp.getId());
|
||||
if (lvl > maxLvl)
|
||||
{
|
||||
lvl = maxLvl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
else if (temp.getMinLevel() <= cha.getLevel())
|
||||
{
|
||||
if (temp.getLevel() > lvl)
|
||||
{
|
||||
lvl = temp.getLevel();
|
||||
}
|
||||
}
|
||||
}
|
||||
return lvl;
|
||||
}
|
||||
|
||||
public List<Integer> getAvailableSkills(L2Summon cha)
|
||||
{
|
||||
final List<Integer> skillIds = new ArrayList<>();
|
||||
if (!_skillTrees.containsKey(cha.getId()))
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Pet id " + cha.getId() + " does not have any skills assigned.");
|
||||
return skillIds;
|
||||
}
|
||||
final Collection<L2PetSkillLearn> skills = _skillTrees.get(cha.getId()).values();
|
||||
for (L2PetSkillLearn temp : skills)
|
||||
{
|
||||
if (skillIds.contains(temp.getId()))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
skillIds.add(temp.getId());
|
||||
}
|
||||
return skillIds;
|
||||
}
|
||||
|
||||
public static final class L2PetSkillLearn
|
||||
{
|
||||
private final int _id;
|
||||
private final int _level;
|
||||
private final int _minLevel;
|
||||
|
||||
public L2PetSkillLearn(int id, int lvl, int minLvl)
|
||||
{
|
||||
_id = id;
|
||||
_level = lvl;
|
||||
_minLevel = minLvl;
|
||||
}
|
||||
|
||||
public int getId()
|
||||
{
|
||||
return _id;
|
||||
}
|
||||
|
||||
public int getLevel()
|
||||
{
|
||||
return _level;
|
||||
}
|
||||
|
||||
public int getMinLevel()
|
||||
{
|
||||
return _minLevel;
|
||||
}
|
||||
}
|
||||
|
||||
public static SummonSkillsTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final SummonSkillsTable _instance = new SummonSkillsTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,123 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.Statement;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.Config;
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.model.L2TeleportLocation;
|
||||
|
||||
public class TeleportLocationTable
|
||||
{
|
||||
private static Logger LOGGER = Logger.getLogger(TeleportLocationTable.class.getName());
|
||||
|
||||
private final Map<Integer, L2TeleportLocation> _teleports = new HashMap<>();
|
||||
|
||||
protected TeleportLocationTable()
|
||||
{
|
||||
reloadAll();
|
||||
}
|
||||
|
||||
public void reloadAll()
|
||||
{
|
||||
_teleports.clear();
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery("SELECT id, loc_x, loc_y, loc_z, price, fornoble, itemId FROM teleport"))
|
||||
{
|
||||
L2TeleportLocation teleport;
|
||||
while (rs.next())
|
||||
{
|
||||
teleport = new L2TeleportLocation();
|
||||
|
||||
teleport.setTeleId(rs.getInt("id"));
|
||||
teleport.setLocX(rs.getInt("loc_x"));
|
||||
teleport.setLocY(rs.getInt("loc_y"));
|
||||
teleport.setLocZ(rs.getInt("loc_z"));
|
||||
teleport.setPrice(rs.getInt("price"));
|
||||
teleport.setIsForNoble(rs.getInt("fornoble") == 1);
|
||||
teleport.setItemId(rs.getInt("itemId"));
|
||||
|
||||
_teleports.put(teleport.getTeleId(), teleport);
|
||||
}
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loaded " + _teleports.size() + " Teleport Location Templates.");
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.SEVERE, getClass().getSimpleName() + ": Error loading Teleport Table.", e);
|
||||
}
|
||||
|
||||
if (Config.CUSTOM_TELEPORT_TABLE)
|
||||
{
|
||||
int _cTeleCount = _teleports.size();
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement s = con.createStatement();
|
||||
ResultSet rs = s.executeQuery("SELECT id, loc_x, loc_y, loc_z, price, fornoble, itemId FROM custom_teleport"))
|
||||
{
|
||||
L2TeleportLocation teleport;
|
||||
while (rs.next())
|
||||
{
|
||||
teleport = new L2TeleportLocation();
|
||||
teleport.setTeleId(rs.getInt("id"));
|
||||
teleport.setLocX(rs.getInt("loc_x"));
|
||||
teleport.setLocY(rs.getInt("loc_y"));
|
||||
teleport.setLocZ(rs.getInt("loc_z"));
|
||||
teleport.setPrice(rs.getInt("price"));
|
||||
teleport.setIsForNoble(rs.getInt("fornoble") == 1);
|
||||
teleport.setItemId(rs.getInt("itemId"));
|
||||
|
||||
_teleports.put(teleport.getTeleId(), teleport);
|
||||
}
|
||||
_cTeleCount = _teleports.size() - _cTeleCount;
|
||||
if (_cTeleCount > 0)
|
||||
{
|
||||
LOGGER.info(getClass().getSimpleName() + ": Loaded " + _cTeleCount + " Custom Teleport Location Templates.");
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Error while creating custom teleport table " + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param id
|
||||
* @return
|
||||
*/
|
||||
public L2TeleportLocation getTemplate(int id)
|
||||
{
|
||||
return _teleports.get(id);
|
||||
}
|
||||
|
||||
public static TeleportLocationTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final TeleportLocationTable _instance = new TeleportLocationTable();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,111 @@
|
||||
/*
|
||||
* This file is part of the L2J Mobius project.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.l2jmobius.gameserver.data.sql.impl;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import com.l2jmobius.commons.database.pool.impl.ConnectionFactory;
|
||||
import com.l2jmobius.gameserver.model.L2Territory;
|
||||
import com.l2jmobius.gameserver.model.Location;
|
||||
|
||||
/**
|
||||
* @author Balancer, Mr
|
||||
*/
|
||||
public class TerritoryTable
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(TerritoryTable.class.getName());
|
||||
|
||||
private static final Map<Integer, L2Territory> _territory = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Instantiates a new territory.
|
||||
*/
|
||||
protected TerritoryTable()
|
||||
{
|
||||
load();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the random point.
|
||||
* @param terr the territory Id?
|
||||
* @return the random point
|
||||
*/
|
||||
public Location getRandomPoint(int terr)
|
||||
{
|
||||
return _territory.get(terr).getRandomPoint();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the proc max.
|
||||
* @param terr the territory Id?
|
||||
* @return the proc max
|
||||
*/
|
||||
public int getProcMax(int terr)
|
||||
{
|
||||
return _territory.get(terr).getProcMax();
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the data from database.
|
||||
*/
|
||||
public void load()
|
||||
{
|
||||
_territory.clear();
|
||||
try (Connection con = ConnectionFactory.getInstance().getConnection();
|
||||
Statement stmt = con.createStatement();
|
||||
ResultSet rset = stmt.executeQuery("SELECT * FROM locations WHERE loc_id>0"))
|
||||
{
|
||||
while (rset.next())
|
||||
{
|
||||
final int terrId = rset.getInt("loc_id");
|
||||
L2Territory terr = _territory.get(terrId);
|
||||
if (terr == null)
|
||||
{
|
||||
terr = new L2Territory(terrId);
|
||||
_territory.put(terrId, terr);
|
||||
}
|
||||
terr.add(rset.getInt("loc_x"), rset.getInt("loc_y"), rset.getInt("loc_zmin"), rset.getInt("loc_zmax"), rset.getInt("proc"));
|
||||
}
|
||||
LOGGER.info("TerritoryTable: Loaded " + _territory.size() + " territories from database.");
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.SEVERE, "TerritoryTable: Failed to load territories from database!", e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the single instance of Territory.
|
||||
* @return single instance of Territory
|
||||
*/
|
||||
public static TerritoryTable getInstance()
|
||||
{
|
||||
return SingletonHolder._instance;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final TerritoryTable _instance = new TerritoryTable();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user