[Share] L2J Announcement with UTF-8

[hoangnhan]

This code for L2J all version  announcement with full UTF-8 , no error load announcement font when restart server.

/L2_GameServer/java/com/l2jserver/gameserver/Announcements.java

 

Click me to see code

 

Credit by me :) from L2JVN

[Grim.]

404 - Not Found

Invalid CID

[hoangnhan]

until work link.

[gRfd`]

good

Good  ? Link not working, lol...

[niksan1]

/*
* 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.l2jserver.gameserver;

import java.io.*;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.l2jserver.Config;
import com.l2jserver.gameserver.cache.HtmCache;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.network.SystemMessageId;
import com.l2jserver.gameserver.network.clientpackets.Say2;
import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
import com.l2jserver.gameserver.network.serverpackets.NpcHtmlMessage;
import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
import com.l2jserver.gameserver.script.DateRange;
import com.l2jserver.gameserver.util.Broadcast;
import com.l2jserver.util.StringUtil;

import javolution.util.FastList;

/**
* This class ...
* @author HoangNhan L2JVN http://vietcheaters.com
* UTF-8 Announcement  
*/
public class Announcements
{
        private static Logger _log = Logger.getLogger(Announcements.class.getName());
        
        private List<String> _announcements = new FastList<String>();
        private List<List<Object>> _eventAnnouncements = new FastList<List<Object>>();
        
        private Announcements()
        {
                loadAnnouncements();
        }
        
        public static Announcements getInstance()
        {
                return SingletonHolder._instance;
        }
        
        public void loadAnnouncements()
        {
                _announcements.clear();
                File file = new File(Config.DATAPACK_ROOT, "data/announcements.txt");
                if (file.exists())
                {
                        readFromDisk(file);
                }
                else
                {
                        _log.warning("data/announcements.txt doesn't exist");
                }
        }
        
        public void showAnnouncements(L2PcInstance activeChar)
        {
                for (int i = 0; i < _announcements.size(); i  )
                {
                        CreatureSay cs = new CreatureSay(0, Say2.ANNOUNCEMENT, activeChar.getName(), _announcements.get(i));
                        activeChar.sendPacket(cs);
                }
                
                for (int i = 0; i < _eventAnnouncements.size(); i  )
                {
                        List<Object> entry = _eventAnnouncements.get(i);
                        
                        DateRange validDateRange = (DateRange) entry.get(0);
                        String[] msg = (String[]) entry.get(1);
                        Date currentDate = new Date();
                        
                        if (!validDateRange.isValid() || validDateRange.isWithinRange(currentDate))
                        {
                                SystemMessage sm = new SystemMessage(SystemMessageId.S1);
                                for (int j = 0; j < msg.length; j  )
                                {
                                        sm.addString(msg[j]);
                                }
                                activeChar.sendPacket(sm);
                        }
                        
                }
        }
        
        public void addEventAnnouncement(DateRange validDateRange, String[] msg)
        {
                List<Object> entry = new FastList<Object>();
                entry.add(validDateRange);
                entry.add(msg);
                _eventAnnouncements.add(entry);
        }
        
        public void listAnnouncements(L2PcInstance activeChar)
        {
                String content = HtmCache.getInstance().getHtmForce(activeChar.getHtmlPrefix(), "data/html/admin/announce.htm");
                NpcHtmlMessage adminReply = new NpcHtmlMessage(5);
                adminReply.setHtml(content);
                final StringBuilder replyMSG = StringUtil.startAppend(500, "<br>");
                for (int i = 0; i < _announcements.size(); i  )
                {
                        StringUtil.append(replyMSG, "<table width=260><tr><td width=220>", _announcements.get(i), "</td><td width=40>"
                                          "<button value="Delete" action="bypass -h admin_del_announcement ", String.valueOf(i), "" width=60 height=20 back="L2UI_ct1.button_df" fore="L2UI_ct1.button_df"></td></tr></table>");
                }
                adminReply.replace("%announces%", replyMSG.toString());
                activeChar.sendPacket(adminReply);
        }
        
        public void addAnnouncement(String text)
        {
                _announcements.add(text);
                saveToDisk();
        }
        
        public void delAnnouncement(int line)
        {
                _announcements.remove(line);
                saveToDisk();
        }
        
        private void readFromDisk(File file)
        {
                BufferedReader lnr = null;
                try
                {
                        int i = 0;
                        String line = null;
                        lnr =  new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF8"));
                        while ((line = lnr.readLine()) != null)
                        {
                                StringTokenizer st = new StringTokenizer(line, "nr");
                                if (st.hasMoreTokens())
                                {
                                        String announcement = st.nextToken();
                                        _announcements.add(announcement);
                                        
                                        i  ;
                                }
                        }
                        
                        if (Config.DEBUG)
                                _log.info("Announcements: Loaded "   i   " Announcements.");
                }
                catch (IOException e1)
                {
                        _log.log(Level.SEVERE, "Error reading announcements: ", e1);
                }
                finally
                {
                        try
                        {
                                lnr.close();
                        }
                        catch (Exception e2)
                        {
                                // nothing
                        }
                }
        }
        
        private void saveToDisk()
        {
                File file = new File("data/announcements.txt");
                BufferedWriter save = null;
                
                try
                {
                        save = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file),"UTF8"));
                        for (int i = 0; i < _announcements.size(); i  )
                        {
                                save.write(_announcements.get(i));
                                save.write("rn");
                        }
                }
                catch (IOException e)
                {
                        _log.log(Level.SEVERE, "Saving to the announcements file has failed: ", e);
                }
                finally
                {
                        try
                        {
                                save.close();
                        }
                        catch (Exception e)
                        {
                        }
                }
        }
        
        public void announceToAll(String text)
        {
                Broadcast.announceToOnlinePlayers(text);
        }
        
        public void announceToAll(SystemMessage sm)
        {
                Broadcast.toAllOnlinePlayers(sm);
        }
        
        public void announceToInstance(SystemMessage sm, int instanceId)
        {
                Broadcast.toPlayersInInstance(sm, instanceId);
        }
        
        // Method for handling announcements from admin
        public void handleAnnounce(String command, int lengthToTrim)
        {
                try
                {
                        // Announce string to everyone on server
                        String text = command.substring(lengthToTrim);
                        SingletonHolder._instance.announceToAll(text);
                }
                
                // No body cares!
                catch (StringIndexOutOfBoundsException e)
                {
                        // empty message.. ignore
                }
        }
        
        @SuppressWarnings("synthetic-access")
        private static class SingletonHolder
        {
                protected static final Announcements _instance = new Announcements();
        }
}