Removal of cron4j and event abstractions.
This commit is contained in:
MobiusDevelopment
@@ -0,0 +1,119 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.commons.time;
|
||||
|
||||
import java.util.GregorianCalendar;
|
||||
import java.util.TimeZone;
|
||||
|
||||
public class AddPattern implements NextTime
|
||||
{
|
||||
private int _monthInc = -1;
|
||||
private int _monthSet = -1;
|
||||
private int _dayOfMonthInc = -1;
|
||||
private int _dayOfMonthSet = -1;
|
||||
private int _hourOfDayInc = -1;
|
||||
private int _hourOfDaySet = -1;
|
||||
private int _minuteInc = -1;
|
||||
private int _minuteSet = -1;
|
||||
|
||||
public AddPattern(String pattern)
|
||||
{
|
||||
String[] timeparts;
|
||||
String[] parts = pattern.split("\\s+");
|
||||
if (parts.length == 2)
|
||||
{
|
||||
String datemodstr;
|
||||
String datepartsstr = parts[0];
|
||||
String[] dateparts = datepartsstr.split(":");
|
||||
if (dateparts.length == 2)
|
||||
{
|
||||
if (dateparts[0].startsWith("+"))
|
||||
{
|
||||
_monthInc = Integer.parseInt(dateparts[0].substring(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
_monthSet = Integer.parseInt(dateparts[0]) - 1;
|
||||
}
|
||||
}
|
||||
if ((datemodstr = dateparts[dateparts.length - 1]).startsWith("+"))
|
||||
{
|
||||
_dayOfMonthInc = Integer.parseInt(datemodstr.substring(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
_dayOfMonthSet = Integer.parseInt(datemodstr);
|
||||
}
|
||||
}
|
||||
if ((timeparts = parts[parts.length - 1].split(":"))[0].startsWith("+"))
|
||||
{
|
||||
_hourOfDayInc = Integer.parseInt(timeparts[0].substring(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
_hourOfDaySet = Integer.parseInt(timeparts[0]);
|
||||
}
|
||||
if (timeparts[1].startsWith("+"))
|
||||
{
|
||||
_minuteInc = Integer.parseInt(timeparts[1].substring(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
_minuteSet = Integer.parseInt(timeparts[1]);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public long next(long millis)
|
||||
{
|
||||
final GregorianCalendar gc = new GregorianCalendar(TimeZone.getDefault());
|
||||
gc.setTimeInMillis(millis);
|
||||
if (_monthInc >= 0)
|
||||
{
|
||||
gc.add(2, _monthInc);
|
||||
}
|
||||
if (_monthSet >= 0)
|
||||
{
|
||||
gc.set(2, _monthSet);
|
||||
}
|
||||
if (_dayOfMonthInc >= 0)
|
||||
{
|
||||
gc.add(5, _dayOfMonthInc);
|
||||
}
|
||||
if (_dayOfMonthSet >= 0)
|
||||
{
|
||||
gc.set(5, _dayOfMonthSet);
|
||||
}
|
||||
if (_hourOfDayInc >= 0)
|
||||
{
|
||||
gc.add(11, _hourOfDayInc);
|
||||
}
|
||||
if (_hourOfDaySet >= 0)
|
||||
{
|
||||
gc.set(11, _hourOfDaySet);
|
||||
}
|
||||
if (_minuteInc >= 0)
|
||||
{
|
||||
gc.add(12, _minuteInc);
|
||||
}
|
||||
if (_minuteSet >= 0)
|
||||
{
|
||||
gc.set(12, _minuteSet);
|
||||
}
|
||||
return gc.getTimeInMillis();
|
||||
}
|
||||
}
|
||||
@@ -1,24 +1,22 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public interface IEventState
|
||||
{
|
||||
}
|
||||
/*
|
||||
* 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 org.l2jmobius.commons.time;
|
||||
|
||||
public interface NextTime
|
||||
{
|
||||
public long next(long var1);
|
||||
}
|
||||
@@ -0,0 +1,841 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.commons.time;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.GregorianCalendar;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.StringTokenizer;
|
||||
import java.util.TimeZone;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import org.l2jmobius.commons.util.Rnd;
|
||||
|
||||
public class SchedulingPattern implements NextTime
|
||||
{
|
||||
private static final int MINUTE_MIN_VALUE = 0;
|
||||
private static final int MINUTE_MAX_VALUE = 59;
|
||||
private static final int HOUR_MIN_VALUE = 0;
|
||||
private static final int HOUR_MAX_VALUE = 23;
|
||||
private static final int DAY_OF_MONTH_MIN_VALUE = 1;
|
||||
private static final int DAY_OF_MONTH_MAX_VALUE = 31;
|
||||
private static final int MONTH_MIN_VALUE = 1;
|
||||
private static final int MONTH_MAX_VALUE = 12;
|
||||
private static final int DAY_OF_WEEK_MIN_VALUE = 0;
|
||||
private static final int DAY_OF_WEEK_MAX_VALUE = 7;
|
||||
private static final ValueParser MINUTE_VALUE_PARSER = new MinuteValueParser();
|
||||
private static final ValueParser HOUR_VALUE_PARSER = new HourValueParser();
|
||||
private static final ValueParser DAY_OF_MONTH_VALUE_PARSER = new DayOfMonthValueParser();
|
||||
private static final ValueParser MONTH_VALUE_PARSER = new MonthValueParser();
|
||||
private static final ValueParser DAY_OF_WEEK_VALUE_PARSER = new DayOfWeekValueParser();
|
||||
private final String _asString;
|
||||
protected List<ValueMatcher> _minuteMatchers = new ArrayList<>();
|
||||
protected List<ValueMatcher> _hourMatchers = new ArrayList<>();
|
||||
protected List<ValueMatcher> _dayOfMonthMatchers = new ArrayList<>();
|
||||
protected List<ValueMatcher> _monthMatchers = new ArrayList<>();
|
||||
protected List<ValueMatcher> _dayOfWeekMatchers = new ArrayList<>();
|
||||
protected int _matcherSize = 0;
|
||||
protected Map<Integer, Integer> _hourAdder = new TreeMap<>();
|
||||
protected Map<Integer, Integer> _hourAdderRnd = new TreeMap<>();
|
||||
protected Map<Integer, Integer> _dayOfYearAdder = new TreeMap<>();
|
||||
protected Map<Integer, Integer> _minuteAdderRnd = new TreeMap<>();
|
||||
protected Map<Integer, Integer> _weekOfYearAdder = new TreeMap<>();
|
||||
|
||||
public static boolean validate(String schedulingPattern)
|
||||
{
|
||||
try
|
||||
{
|
||||
new SchedulingPattern(schedulingPattern);
|
||||
}
|
||||
catch (RuntimeException e)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public SchedulingPattern(String pattern) throws RuntimeException
|
||||
{
|
||||
_asString = pattern;
|
||||
StringTokenizer st1 = new StringTokenizer(pattern, "|");
|
||||
if (st1.countTokens() < 1)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern: \"" + pattern + "\"");
|
||||
}
|
||||
|
||||
while (st1.hasMoreTokens())
|
||||
{
|
||||
int i;
|
||||
String localPattern = st1.nextToken();
|
||||
StringTokenizer st2 = new StringTokenizer(localPattern, " \t");
|
||||
int tokCnt = st2.countTokens();
|
||||
if ((tokCnt < 5) || (tokCnt > 6))
|
||||
{
|
||||
throw new RuntimeException("invalid pattern: \"" + localPattern + "\"");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
String minutePattern = st2.nextToken();
|
||||
String[] minutePatternParts = minutePattern.split(":");
|
||||
if (minutePatternParts.length > 1)
|
||||
{
|
||||
for (i = 0; i < (minutePatternParts.length - 1); ++i)
|
||||
{
|
||||
if (minutePatternParts[i].length() <= 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (minutePatternParts[i].startsWith("~"))
|
||||
{
|
||||
_minuteAdderRnd.put(_matcherSize, Integer.parseInt(minutePatternParts[i].substring(1)));
|
||||
continue;
|
||||
}
|
||||
|
||||
throw new RuntimeException("Unknown hour modifier \"" + minutePatternParts[i] + "\"");
|
||||
}
|
||||
minutePattern = minutePatternParts[minutePatternParts.length - 1];
|
||||
}
|
||||
_minuteMatchers.add(buildValueMatcher(minutePattern, MINUTE_VALUE_PARSER));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern \"" + localPattern + "\". Error parsing minutes field: " + e.getMessage() + ".");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
String hourPattern = st2.nextToken();
|
||||
String[] hourPatternParts = hourPattern.split(":");
|
||||
if (hourPatternParts.length > 1)
|
||||
{
|
||||
for (i = 0; i < (hourPatternParts.length - 1); ++i)
|
||||
{
|
||||
if (hourPatternParts[i].length() <= 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (hourPatternParts[i].startsWith("+"))
|
||||
{
|
||||
_hourAdder.put(_matcherSize, Integer.parseInt(hourPatternParts[i].substring(1)));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (hourPatternParts[i].startsWith("~"))
|
||||
{
|
||||
_hourAdderRnd.put(_matcherSize, Integer.parseInt(hourPatternParts[i].substring(1)));
|
||||
continue;
|
||||
}
|
||||
|
||||
throw new RuntimeException("Unknown hour modifier \"" + hourPatternParts[i] + "\"");
|
||||
}
|
||||
hourPattern = hourPatternParts[hourPatternParts.length - 1];
|
||||
}
|
||||
_hourMatchers.add(buildValueMatcher(hourPattern, HOUR_VALUE_PARSER));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern \"" + localPattern + "\". Error parsing hours field: " + e.getMessage() + ".");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
String dayOfMonthPattern = st2.nextToken();
|
||||
String[] dayOfMonthPatternParts = dayOfMonthPattern.split(":");
|
||||
if (dayOfMonthPatternParts.length > 1)
|
||||
{
|
||||
for (i = 0; i < (dayOfMonthPatternParts.length - 1); ++i)
|
||||
{
|
||||
if (dayOfMonthPatternParts[i].length() <= 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (dayOfMonthPatternParts[i].startsWith("+"))
|
||||
{
|
||||
_dayOfYearAdder.put(_matcherSize, Integer.parseInt(dayOfMonthPatternParts[i].substring(1)));
|
||||
continue;
|
||||
}
|
||||
|
||||
throw new RuntimeException("Unknown day modifier \"" + dayOfMonthPatternParts[i] + "\"");
|
||||
}
|
||||
dayOfMonthPattern = dayOfMonthPatternParts[dayOfMonthPatternParts.length - 1];
|
||||
}
|
||||
_dayOfMonthMatchers.add(buildValueMatcher(dayOfMonthPattern, DAY_OF_MONTH_VALUE_PARSER));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern \"" + localPattern + "\". Error parsing days of month field: " + e.getMessage() + ".");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
_monthMatchers.add(buildValueMatcher(st2.nextToken(), MONTH_VALUE_PARSER));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern \"" + localPattern + "\". Error parsing months field: " + e.getMessage() + ".");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
_dayOfWeekMatchers.add(buildValueMatcher(st2.nextToken(), DAY_OF_WEEK_VALUE_PARSER));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern \"" + localPattern + "\". Error parsing days of week field: " + e.getMessage() + ".");
|
||||
}
|
||||
|
||||
if (st2.hasMoreTokens())
|
||||
{
|
||||
try
|
||||
{
|
||||
String weekOfYearAdderText = st2.nextToken();
|
||||
if (weekOfYearAdderText.charAt(0) != '+')
|
||||
{
|
||||
throw new RuntimeException("Unknown week of year addition in pattern \"" + localPattern + "\".");
|
||||
}
|
||||
weekOfYearAdderText = weekOfYearAdderText.substring(1);
|
||||
_weekOfYearAdder.put(_matcherSize, Integer.parseInt(weekOfYearAdderText));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new RuntimeException("invalid pattern \"" + localPattern + "\". Error parsing days of week field: " + e.getMessage() + ".");
|
||||
}
|
||||
}
|
||||
++_matcherSize;
|
||||
}
|
||||
}
|
||||
|
||||
private ValueMatcher buildValueMatcher(String str, ValueParser parser) throws Exception
|
||||
{
|
||||
if ((str.length() == 1) && str.equals("*"))
|
||||
{
|
||||
return new AlwaysTrueValueMatcher();
|
||||
}
|
||||
|
||||
ArrayList<Integer> values = new ArrayList<>();
|
||||
StringTokenizer st = new StringTokenizer(str, ",");
|
||||
while (st.hasMoreTokens())
|
||||
{
|
||||
List<Integer> local;
|
||||
String element = st.nextToken();
|
||||
try
|
||||
{
|
||||
local = parseListElement(element, parser);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new Exception("invalid field \"" + str + "\", invalid element \"" + element + "\", " + e.getMessage());
|
||||
}
|
||||
|
||||
for (Integer value : local)
|
||||
{
|
||||
if (values.contains(value))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
values.add(value);
|
||||
}
|
||||
}
|
||||
|
||||
if (values.size() == 0)
|
||||
{
|
||||
throw new Exception("invalid field \"" + str + "\"");
|
||||
}
|
||||
|
||||
if (parser == DAY_OF_MONTH_VALUE_PARSER)
|
||||
{
|
||||
return new DayOfMonthValueMatcher(values);
|
||||
}
|
||||
|
||||
return new IntArrayValueMatcher(values);
|
||||
}
|
||||
|
||||
private List<Integer> parseListElement(String str, ValueParser parser) throws Exception
|
||||
{
|
||||
List<Integer> values;
|
||||
StringTokenizer st = new StringTokenizer(str, "/");
|
||||
int size = st.countTokens();
|
||||
if ((size < 1) || (size > 2))
|
||||
{
|
||||
throw new Exception("syntax error");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
values = parseRange(st.nextToken(), parser);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new Exception("invalid range, " + e.getMessage());
|
||||
}
|
||||
|
||||
if (size == 2)
|
||||
{
|
||||
int div;
|
||||
String dStr = st.nextToken();
|
||||
|
||||
try
|
||||
{
|
||||
div = Integer.parseInt(dStr);
|
||||
}
|
||||
catch (NumberFormatException e)
|
||||
{
|
||||
throw new Exception("invalid divisor \"" + dStr + "\"");
|
||||
}
|
||||
|
||||
if (div < 1)
|
||||
{
|
||||
throw new Exception("non positive divisor \"" + div + "\"");
|
||||
}
|
||||
|
||||
ArrayList<Integer> values2 = new ArrayList<>();
|
||||
for (int i = 0; i < values.size(); i += div)
|
||||
{
|
||||
values2.add(values.get(i));
|
||||
}
|
||||
|
||||
return values2;
|
||||
}
|
||||
return values;
|
||||
}
|
||||
|
||||
private List<Integer> parseRange(String str, ValueParser parser) throws Exception
|
||||
{
|
||||
int v2;
|
||||
int v1;
|
||||
if (str.equals("*"))
|
||||
{
|
||||
int min = parser.getMinValue();
|
||||
int max = parser.getMaxValue();
|
||||
ArrayList<Integer> values = new ArrayList<>();
|
||||
for (int i = min; i <= max; ++i)
|
||||
{
|
||||
values.add(i);
|
||||
}
|
||||
return values;
|
||||
}
|
||||
|
||||
StringTokenizer st = new StringTokenizer(str, "-");
|
||||
int size = st.countTokens();
|
||||
if ((size < 1) || (size > 2))
|
||||
{
|
||||
throw new Exception("syntax error");
|
||||
}
|
||||
|
||||
String v1Str = st.nextToken();
|
||||
try
|
||||
{
|
||||
v1 = parser.parse(v1Str);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new Exception("invalid value \"" + v1Str + "\", " + e.getMessage());
|
||||
}
|
||||
|
||||
if (size == 1)
|
||||
{
|
||||
ArrayList<Integer> values = new ArrayList<>();
|
||||
values.add(v1);
|
||||
return values;
|
||||
}
|
||||
|
||||
String v2Str = st.nextToken();
|
||||
try
|
||||
{
|
||||
v2 = parser.parse(v2Str);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new Exception("invalid value \"" + v2Str + "\", " + e.getMessage());
|
||||
}
|
||||
|
||||
ArrayList<Integer> values = new ArrayList<>();
|
||||
if (v1 < v2)
|
||||
{
|
||||
for (int i = v1; i <= v2; ++i)
|
||||
{
|
||||
values.add(i);
|
||||
}
|
||||
}
|
||||
else if (v1 > v2)
|
||||
{
|
||||
int i;
|
||||
int min = parser.getMinValue();
|
||||
int max = parser.getMaxValue();
|
||||
for (i = v1; i <= max; ++i)
|
||||
{
|
||||
values.add(i);
|
||||
}
|
||||
for (i = min; i <= v2; ++i)
|
||||
{
|
||||
values.add(i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
values.add(v1);
|
||||
}
|
||||
|
||||
return values;
|
||||
}
|
||||
|
||||
public boolean match(TimeZone timezone, long millis)
|
||||
{
|
||||
GregorianCalendar gc = new GregorianCalendar(timezone);
|
||||
gc.setTimeInMillis(millis);
|
||||
gc.set(13, 0);
|
||||
gc.set(14, 0);
|
||||
for (int i = 0; i < _matcherSize; ++i)
|
||||
{
|
||||
boolean eval = false;
|
||||
if (_weekOfYearAdder.containsKey(i))
|
||||
{
|
||||
gc.add(3, -_weekOfYearAdder.get(i).intValue());
|
||||
}
|
||||
if (_dayOfYearAdder.containsKey(i))
|
||||
{
|
||||
gc.add(6, -_dayOfYearAdder.get(i).intValue());
|
||||
}
|
||||
if (_hourAdder.containsKey(i))
|
||||
{
|
||||
gc.add(10, -_hourAdder.get(i).intValue());
|
||||
}
|
||||
int minute = gc.get(MONTH_MAX_VALUE);
|
||||
int hour = gc.get(11);
|
||||
int dayOfMonth = gc.get(5);
|
||||
int month = gc.get(2) + 1;
|
||||
int dayOfWeek = gc.get(DAY_OF_WEEK_MAX_VALUE) - 1;
|
||||
int year = gc.get(1);
|
||||
ValueMatcher minuteMatcher = _minuteMatchers.get(i);
|
||||
ValueMatcher hourMatcher = _hourMatchers.get(i);
|
||||
ValueMatcher dayOfMonthMatcher = _dayOfMonthMatchers.get(i);
|
||||
ValueMatcher monthMatcher = _monthMatchers.get(i);
|
||||
ValueMatcher dayOfWeekMatcher = _dayOfWeekMatchers.get(i);
|
||||
@SuppressWarnings("unused")
|
||||
boolean bl = minuteMatcher.match(minute) && hourMatcher.match(hour) && (dayOfMonthMatcher instanceof DayOfMonthValueMatcher ? ((DayOfMonthValueMatcher) dayOfMonthMatcher).match(dayOfMonth, month, gc.isLeapYear(year)) : dayOfMonthMatcher.match(dayOfMonth)) && monthMatcher.match(month) && dayOfWeekMatcher.match(dayOfWeek) ? true : (eval = false);
|
||||
if (!eval)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean match(long millis)
|
||||
{
|
||||
return match(TimeZone.getDefault(), millis);
|
||||
}
|
||||
|
||||
public long next(TimeZone timezone, long millis)
|
||||
{
|
||||
long result = -1L;
|
||||
GregorianCalendar gc = new GregorianCalendar(timezone);
|
||||
for (int i = 0; i < _matcherSize; ++i)
|
||||
{
|
||||
long next = -1L;
|
||||
gc.setTimeInMillis(millis);
|
||||
gc.set(13, 0);
|
||||
gc.set(14, 0);
|
||||
if (_weekOfYearAdder.containsKey(i))
|
||||
{
|
||||
gc.add(3, _weekOfYearAdder.get(i));
|
||||
}
|
||||
if (_dayOfYearAdder.containsKey(i))
|
||||
{
|
||||
gc.add(6, _dayOfYearAdder.get(i));
|
||||
}
|
||||
if (_hourAdder.containsKey(i))
|
||||
{
|
||||
gc.add(10, _hourAdder.get(i));
|
||||
}
|
||||
ValueMatcher minuteMatcher = _minuteMatchers.get(i);
|
||||
ValueMatcher hourMatcher = _hourMatchers.get(i);
|
||||
ValueMatcher dayOfMonthMatcher = _dayOfMonthMatchers.get(i);
|
||||
ValueMatcher monthMatcher = _monthMatchers.get(i);
|
||||
ValueMatcher dayOfWeekMatcher = _dayOfWeekMatchers.get(i);
|
||||
SEARCH: do
|
||||
{
|
||||
int year = gc.get(1);
|
||||
boolean isLeapYear = gc.isLeapYear(year);
|
||||
for (int month = gc.get(2) + 1; month <= MONTH_MAX_VALUE; ++month)
|
||||
{
|
||||
if (monthMatcher.match(month))
|
||||
{
|
||||
gc.set(2, month - 1);
|
||||
int maxDayOfMonth = DayOfMonthValueMatcher.getLastDayOfMonth(month, isLeapYear);
|
||||
for (int dayOfMonth = gc.get(5); dayOfMonth <= maxDayOfMonth; ++dayOfMonth)
|
||||
{
|
||||
if (dayOfMonthMatcher instanceof DayOfMonthValueMatcher ? ((DayOfMonthValueMatcher) dayOfMonthMatcher).match(dayOfMonth, month, isLeapYear) : dayOfMonthMatcher.match(dayOfMonth))
|
||||
{
|
||||
gc.set(5, dayOfMonth);
|
||||
int dayOfWeek = gc.get(DAY_OF_WEEK_MAX_VALUE) - 1;
|
||||
if (dayOfWeekMatcher.match(dayOfWeek))
|
||||
{
|
||||
for (int hour = gc.get(11); hour <= HOUR_MAX_VALUE; ++hour)
|
||||
{
|
||||
if (hourMatcher.match(hour))
|
||||
{
|
||||
gc.set(11, hour);
|
||||
for (int minute = gc.get(MONTH_MAX_VALUE); minute <= MINUTE_MAX_VALUE; ++minute)
|
||||
{
|
||||
if (!minuteMatcher.match(minute))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
gc.set(MONTH_MAX_VALUE, minute);
|
||||
long next0 = gc.getTimeInMillis();
|
||||
if (next0 <= millis)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((next != -1L) && (next0 >= next))
|
||||
{
|
||||
break SEARCH;
|
||||
}
|
||||
|
||||
next = next0;
|
||||
if (_hourAdderRnd.containsKey(i))
|
||||
{
|
||||
next += Rnd.get(_hourAdderRnd.get(i)) * 60 * 60 * 1000L;
|
||||
}
|
||||
|
||||
if (!_minuteAdderRnd.containsKey(i))
|
||||
{
|
||||
break SEARCH;
|
||||
}
|
||||
|
||||
next += Rnd.get(_minuteAdderRnd.get(i)) * 60 * 1000L;
|
||||
break SEARCH;
|
||||
}
|
||||
}
|
||||
gc.set(MONTH_MAX_VALUE, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
gc.set(11, 0);
|
||||
gc.set(MONTH_MAX_VALUE, 0);
|
||||
}
|
||||
}
|
||||
gc.set(5, 1);
|
||||
gc.set(11, 0);
|
||||
gc.set(MONTH_MAX_VALUE, 0);
|
||||
}
|
||||
gc.set(2, 0);
|
||||
gc.set(11, 0);
|
||||
gc.set(MONTH_MAX_VALUE, 0);
|
||||
gc.roll(1, true);
|
||||
}
|
||||
|
||||
while (true);
|
||||
if ((next <= millis) || ((result != -1L) && (next >= result)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
result = next;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long next(long millis)
|
||||
{
|
||||
return next(TimeZone.getDefault(), millis);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString()
|
||||
{
|
||||
return _asString;
|
||||
}
|
||||
|
||||
private static int parseAlias(String value, String[] aliases, int offset) throws Exception
|
||||
{
|
||||
for (int i = 0; i < aliases.length; ++i)
|
||||
{
|
||||
if (!aliases[i].equalsIgnoreCase(value))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
return offset + i;
|
||||
}
|
||||
throw new Exception("invalid alias \"" + value + "\"");
|
||||
}
|
||||
|
||||
private static class DayOfMonthValueMatcher extends IntArrayValueMatcher
|
||||
{
|
||||
private static final int[] lastDays = new int[]
|
||||
{
|
||||
DAY_OF_MONTH_MAX_VALUE,
|
||||
28,
|
||||
DAY_OF_MONTH_MAX_VALUE,
|
||||
30,
|
||||
DAY_OF_MONTH_MAX_VALUE,
|
||||
30,
|
||||
DAY_OF_MONTH_MAX_VALUE,
|
||||
DAY_OF_MONTH_MAX_VALUE,
|
||||
30,
|
||||
DAY_OF_MONTH_MAX_VALUE,
|
||||
30,
|
||||
DAY_OF_MONTH_MAX_VALUE
|
||||
};
|
||||
|
||||
public DayOfMonthValueMatcher(List<Integer> integers)
|
||||
{
|
||||
super(integers);
|
||||
}
|
||||
|
||||
public boolean match(int value, int month, boolean isLeapYear)
|
||||
{
|
||||
return super.match(value) || ((value > 27) && match(32) && DayOfMonthValueMatcher.isLastDayOfMonth(value, month, isLeapYear));
|
||||
}
|
||||
|
||||
public static int getLastDayOfMonth(int month, boolean isLeapYear)
|
||||
{
|
||||
if (isLeapYear && (month == 2))
|
||||
{
|
||||
return 29;
|
||||
}
|
||||
|
||||
return lastDays[month - 1];
|
||||
}
|
||||
|
||||
public static boolean isLastDayOfMonth(int value, int month, boolean isLeapYear)
|
||||
{
|
||||
return value == DayOfMonthValueMatcher.getLastDayOfMonth(month, isLeapYear);
|
||||
}
|
||||
}
|
||||
|
||||
private static class IntArrayValueMatcher implements ValueMatcher
|
||||
{
|
||||
private final int[] values;
|
||||
|
||||
public IntArrayValueMatcher(List<Integer> integers)
|
||||
{
|
||||
int size = integers.size();
|
||||
values = new int[size];
|
||||
for (int i = 0; i < size; ++i)
|
||||
{
|
||||
try
|
||||
{
|
||||
values[i] = integers.get(i);
|
||||
continue;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new IllegalArgumentException(e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean match(int value)
|
||||
{
|
||||
for (int i = 0; i < values.length; ++i)
|
||||
{
|
||||
if (values[i] != value)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static class AlwaysTrueValueMatcher implements ValueMatcher
|
||||
{
|
||||
private AlwaysTrueValueMatcher()
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean match(int value)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private static interface ValueMatcher
|
||||
{
|
||||
public boolean match(int var1);
|
||||
}
|
||||
|
||||
private static class DayOfWeekValueParser extends SimpleValueParser
|
||||
{
|
||||
private static String[] ALIASES = new String[]
|
||||
{
|
||||
"sun",
|
||||
"mon",
|
||||
"tue",
|
||||
"wed",
|
||||
"thu",
|
||||
"fri",
|
||||
"sat"
|
||||
};
|
||||
|
||||
public DayOfWeekValueParser()
|
||||
{
|
||||
super(DAY_OF_WEEK_MIN_VALUE, DAY_OF_WEEK_MAX_VALUE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int parse(String value) throws Exception
|
||||
{
|
||||
try
|
||||
{
|
||||
return super.parse(value) % DAY_OF_WEEK_MAX_VALUE;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
return SchedulingPattern.parseAlias(value, ALIASES, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static class MonthValueParser extends SimpleValueParser
|
||||
{
|
||||
private static String[] ALIASES = new String[]
|
||||
{
|
||||
"jan",
|
||||
"feb",
|
||||
"mar",
|
||||
"apr",
|
||||
"may",
|
||||
"jun",
|
||||
"jul",
|
||||
"aug",
|
||||
"sep",
|
||||
"oct",
|
||||
"nov",
|
||||
"dec"
|
||||
};
|
||||
|
||||
public MonthValueParser()
|
||||
{
|
||||
super(MONTH_MIN_VALUE, MONTH_MAX_VALUE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int parse(String value) throws Exception
|
||||
{
|
||||
try
|
||||
{
|
||||
return super.parse(value);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
return SchedulingPattern.parseAlias(value, ALIASES, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static class DayOfMonthValueParser extends SimpleValueParser
|
||||
{
|
||||
public DayOfMonthValueParser()
|
||||
{
|
||||
super(DAY_OF_MONTH_MIN_VALUE, DAY_OF_MONTH_MAX_VALUE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int parse(String value) throws Exception
|
||||
{
|
||||
if (value.equalsIgnoreCase("L"))
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
return super.parse(value);
|
||||
}
|
||||
}
|
||||
|
||||
private static class HourValueParser extends SimpleValueParser
|
||||
{
|
||||
public HourValueParser()
|
||||
{
|
||||
super(HOUR_MIN_VALUE, HOUR_MAX_VALUE);
|
||||
}
|
||||
}
|
||||
|
||||
private static class MinuteValueParser extends SimpleValueParser
|
||||
{
|
||||
public MinuteValueParser()
|
||||
{
|
||||
super(MINUTE_MIN_VALUE, MINUTE_MAX_VALUE);
|
||||
}
|
||||
}
|
||||
|
||||
private static class SimpleValueParser implements ValueParser
|
||||
{
|
||||
protected int _minValue;
|
||||
protected int _maxValue;
|
||||
|
||||
public SimpleValueParser(int minValue, int maxValue)
|
||||
{
|
||||
_minValue = minValue;
|
||||
_maxValue = maxValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int parse(String value) throws Exception
|
||||
{
|
||||
int i;
|
||||
try
|
||||
{
|
||||
i = Integer.parseInt(value);
|
||||
}
|
||||
catch (NumberFormatException e)
|
||||
{
|
||||
throw new Exception("invalid integer value");
|
||||
}
|
||||
if ((i < _minValue) || (i > _maxValue))
|
||||
{
|
||||
throw new Exception("value out of range");
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMinValue()
|
||||
{
|
||||
return _minValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxValue()
|
||||
{
|
||||
return _maxValue;
|
||||
}
|
||||
}
|
||||
|
||||
private static interface ValueParser
|
||||
{
|
||||
public int parse(String var1) throws Exception;
|
||||
|
||||
public int getMinValue();
|
||||
|
||||
public int getMaxValue();
|
||||
}
|
||||
}
|
||||
@@ -69,7 +69,6 @@ import org.l2jmobius.gameserver.data.xml.EnchantItemHPBonusData;
|
||||
import org.l2jmobius.gameserver.data.xml.EnchantItemOptionsData;
|
||||
import org.l2jmobius.gameserver.data.xml.EnchantSkillGroupsData;
|
||||
import org.l2jmobius.gameserver.data.xml.EnsoulData;
|
||||
import org.l2jmobius.gameserver.data.xml.EventEngineData;
|
||||
import org.l2jmobius.gameserver.data.xml.ExperienceData;
|
||||
import org.l2jmobius.gameserver.data.xml.FakePlayerData;
|
||||
import org.l2jmobius.gameserver.data.xml.FenceData;
|
||||
@@ -389,8 +388,6 @@ public class GameServer
|
||||
SpawnData.getInstance().init();
|
||||
DBSpawnManager.getInstance();
|
||||
|
||||
printSection("Event Engine");
|
||||
EventEngineData.getInstance();
|
||||
VoteSystem.initialize();
|
||||
|
||||
printSection("Siege");
|
||||
|
||||
@@ -28,7 +28,6 @@ import org.l2jmobius.gameserver.data.BotReportTable;
|
||||
import org.l2jmobius.gameserver.data.sql.ClanTable;
|
||||
import org.l2jmobius.gameserver.data.sql.OfflineTraderTable;
|
||||
import org.l2jmobius.gameserver.instancemanager.CastleManorManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.CeremonyOfChaosManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.CursedWeaponsManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.DBSpawnManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.GlobalVariablesManager;
|
||||
@@ -452,8 +451,6 @@ public class Shutdown extends Thread
|
||||
LOGGER.info("Item Auction Manager: All tasks stopped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
|
||||
Olympiad.getInstance().saveOlympiadStatus();
|
||||
LOGGER.info("Olympiad System: Data saved(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
|
||||
CeremonyOfChaosManager.getInstance().stopScheduler();
|
||||
LOGGER.info("CeremonyOfChaosManager: Scheduler stopped(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
|
||||
|
||||
Hero.getInstance().shutdown();
|
||||
LOGGER.info("Hero System: Data saved(" + tc.getEstimatedTimeAndRestartCounter() + "ms).");
|
||||
|
||||
@@ -1,582 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.data.xml;
|
||||
|
||||
import java.io.File;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.w3c.dom.Document;
|
||||
import org.w3c.dom.NamedNodeMap;
|
||||
import org.w3c.dom.Node;
|
||||
|
||||
import org.l2jmobius.commons.util.IXmlReader;
|
||||
import org.l2jmobius.gameserver.model.Location;
|
||||
import org.l2jmobius.gameserver.model.StatSet;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.EventMethodNotification;
|
||||
import org.l2jmobius.gameserver.model.eventengine.EventScheduler;
|
||||
import org.l2jmobius.gameserver.model.eventengine.IConditionalEventScheduler;
|
||||
import org.l2jmobius.gameserver.model.eventengine.conditions.BetweenConditionalScheduler;
|
||||
import org.l2jmobius.gameserver.model.eventengine.conditions.HaventRunConditionalScheduler;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.EventDropGroup;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.EventDropItem;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.EventDrops;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.GroupedDrop;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.IEventDrop;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.NormalDrop;
|
||||
import org.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.SkillHolder;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class EventEngineData implements IXmlReader
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(EventEngineData.class.getName());
|
||||
|
||||
protected EventEngineData()
|
||||
{
|
||||
load();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void load()
|
||||
{
|
||||
parseDatapackDirectory("data/events", true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void parseDocument(Document doc, File f)
|
||||
{
|
||||
for (Node listNode = doc.getFirstChild(); listNode != null; listNode = listNode.getNextSibling())
|
||||
{
|
||||
if ("list".equals(listNode.getNodeName()))
|
||||
{
|
||||
for (Node eventNode = listNode.getFirstChild(); eventNode != null; eventNode = eventNode.getNextSibling())
|
||||
{
|
||||
if ("event".equals(eventNode.getNodeName()))
|
||||
{
|
||||
parseEvent(eventNode);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param eventNode
|
||||
*/
|
||||
private void parseEvent(Node eventNode)
|
||||
{
|
||||
final String eventName = parseString(eventNode.getAttributes(), "name");
|
||||
final String className = parseString(eventNode.getAttributes(), "class");
|
||||
AbstractEventManager<?> eventManager = null;
|
||||
try
|
||||
{
|
||||
final Class<?> clazz = Class.forName(className);
|
||||
|
||||
// Attempt to find getInstance() method
|
||||
for (Method method : clazz.getMethods())
|
||||
{
|
||||
if (Modifier.isStatic(method.getModifiers()) && AbstractEventManager.class.isAssignableFrom(method.getReturnType()) && (method.getParameterCount() == 0))
|
||||
{
|
||||
eventManager = (AbstractEventManager<?>) method.invoke(null);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (eventManager == null)
|
||||
{
|
||||
throw new NoSuchMethodError("Couldn't method that gives instance of AbstractEventManager!");
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Couldn't locate event manager instance for event: " + eventName + " !", e);
|
||||
return;
|
||||
}
|
||||
|
||||
for (Node innerNode = eventNode.getFirstChild(); innerNode != null; innerNode = innerNode.getNextSibling())
|
||||
{
|
||||
if ("variables".equals(innerNode.getNodeName()))
|
||||
{
|
||||
parseVariables(eventManager, innerNode);
|
||||
}
|
||||
else if ("scheduler".equals(innerNode.getNodeName()))
|
||||
{
|
||||
parseScheduler(eventManager, innerNode);
|
||||
}
|
||||
else if ("rewards".equals(innerNode.getNodeName()))
|
||||
{
|
||||
parseRewards(eventManager, innerNode);
|
||||
}
|
||||
}
|
||||
|
||||
// Assign event name
|
||||
eventManager.setName(eventName);
|
||||
|
||||
// Start the scheduler
|
||||
eventManager.startScheduler();
|
||||
|
||||
// Start conditional schedulers
|
||||
eventManager.startConditionalSchedulers();
|
||||
|
||||
// Notify the event manager that we've done initializing its stuff
|
||||
eventManager.onInitialized();
|
||||
|
||||
LOGGER.info(getClass().getSimpleName() + ": " + eventManager.getClass().getSimpleName() + ": Initialized.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param eventManager
|
||||
* @param innerNode
|
||||
*/
|
||||
private void parseVariables(AbstractEventManager<?> eventManager, Node innerNode)
|
||||
{
|
||||
final StatSet variables = new StatSet(LinkedHashMap::new);
|
||||
for (Node variableNode = innerNode.getFirstChild(); variableNode != null; variableNode = variableNode.getNextSibling())
|
||||
{
|
||||
if ("variable".equals(variableNode.getNodeName()))
|
||||
{
|
||||
variables.set(parseString(variableNode.getAttributes(), "name"), parseString(variableNode.getAttributes(), "value"));
|
||||
}
|
||||
else if ("list".equals(variableNode.getNodeName()))
|
||||
{
|
||||
parseListVariables(eventManager, variables, variableNode);
|
||||
}
|
||||
else if ("map".equals(variableNode.getNodeName()))
|
||||
{
|
||||
parseMapVariables(eventManager, variables, variableNode);
|
||||
}
|
||||
}
|
||||
eventManager.setVariables(variables);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param eventManager
|
||||
* @param innerNode
|
||||
*/
|
||||
private void parseScheduler(AbstractEventManager<?> eventManager, Node innerNode)
|
||||
{
|
||||
eventManager.stopScheduler();
|
||||
final Set<EventScheduler> schedulers = new LinkedHashSet<>();
|
||||
final Set<IConditionalEventScheduler> conditionalSchedulers = new LinkedHashSet<>();
|
||||
for (Node scheduleNode = innerNode.getFirstChild(); scheduleNode != null; scheduleNode = scheduleNode.getNextSibling())
|
||||
{
|
||||
if ("schedule".equals(scheduleNode.getNodeName()))
|
||||
{
|
||||
final StatSet params = new StatSet(LinkedHashMap::new);
|
||||
final NamedNodeMap attrs = scheduleNode.getAttributes();
|
||||
for (int i = 0; i < attrs.getLength(); i++)
|
||||
{
|
||||
final Node node = attrs.item(i);
|
||||
params.set(node.getNodeName(), node.getNodeValue());
|
||||
}
|
||||
|
||||
final EventScheduler scheduler = new EventScheduler(eventManager, params);
|
||||
for (Node eventNode = scheduleNode.getFirstChild(); eventNode != null; eventNode = eventNode.getNextSibling())
|
||||
{
|
||||
if ("event".equals(eventNode.getNodeName()))
|
||||
{
|
||||
String methodName = parseString(eventNode.getAttributes(), "name");
|
||||
if (methodName.charAt(0) == '#')
|
||||
{
|
||||
methodName = methodName.substring(1);
|
||||
}
|
||||
|
||||
final List<Object> args = new ArrayList<>();
|
||||
for (Node argsNode = eventNode.getFirstChild(); argsNode != null; argsNode = argsNode.getNextSibling())
|
||||
{
|
||||
if ("arg".equals(argsNode.getNodeName()))
|
||||
{
|
||||
final String type = parseString(argsNode.getAttributes(), "type");
|
||||
final Object value = parseObject(eventManager, type, argsNode.getTextContent());
|
||||
if (value != null)
|
||||
{
|
||||
args.add(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
scheduler.addEventNotification(new EventMethodNotification(eventManager, methodName, args));
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, getClass().getSimpleName() + ": Couldn't add event notification for " + eventManager.getClass().getSimpleName(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
schedulers.add(scheduler);
|
||||
}
|
||||
else if ("conditionalSchedule".equals(scheduleNode.getNodeName()))
|
||||
{
|
||||
final StatSet params = new StatSet(LinkedHashMap::new);
|
||||
final NamedNodeMap attrs = scheduleNode.getAttributes();
|
||||
for (int i = 0; i < attrs.getLength(); i++)
|
||||
{
|
||||
final Node node = attrs.item(i);
|
||||
params.set(node.getNodeName(), node.getNodeValue());
|
||||
}
|
||||
|
||||
for (Node eventNode = scheduleNode.getFirstChild(); eventNode != null; eventNode = eventNode.getNextSibling())
|
||||
{
|
||||
if ("run".equals(eventNode.getNodeName()))
|
||||
{
|
||||
final String name = parseString(eventNode.getAttributes(), "name");
|
||||
final String ifType = parseString(eventNode.getAttributes(), "if", "BETWEEN").toUpperCase();
|
||||
switch (ifType)
|
||||
{
|
||||
case "BETWEEN":
|
||||
{
|
||||
final List<String> names = new ArrayList<>(2);
|
||||
for (Node innerData = eventNode.getFirstChild(); innerData != null; innerData = innerData.getNextSibling())
|
||||
{
|
||||
if ("name".equals(innerData.getNodeName()))
|
||||
{
|
||||
names.add(innerData.getTextContent());
|
||||
}
|
||||
}
|
||||
if (names.size() != 2)
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Event: " + eventManager.getClass().getSimpleName() + " has incorrect amount of scheduler names: " + names + " expected: 2 found: " + names.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
conditionalSchedulers.add(new BetweenConditionalScheduler(eventManager, name, names.get(0), names.get(1)));
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "HASNT_RUN":
|
||||
{
|
||||
conditionalSchedulers.add(new HaventRunConditionalScheduler(eventManager, name));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
eventManager.setSchedulers(schedulers);
|
||||
eventManager.setConditionalSchedulers(conditionalSchedulers);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param eventManager
|
||||
* @param innerNode
|
||||
*/
|
||||
private void parseRewards(AbstractEventManager<?> eventManager, Node innerNode)
|
||||
{
|
||||
final Map<String, IEventDrop> rewards = new LinkedHashMap<>();
|
||||
forEach(innerNode, IXmlReader::isNode, rewardsNode ->
|
||||
{
|
||||
if ("reward".equalsIgnoreCase(rewardsNode.getNodeName()))
|
||||
{
|
||||
final String name = parseString(rewardsNode.getAttributes(), "name");
|
||||
final EventDrops dropType = parseEnum(rewardsNode.getAttributes(), EventDrops.class, "type");
|
||||
switch (dropType)
|
||||
{
|
||||
case GROUPED:
|
||||
{
|
||||
final GroupedDrop droplist = dropType.newInstance();
|
||||
forEach(rewardsNode, "group", groupsNode ->
|
||||
{
|
||||
final EventDropGroup group = new EventDropGroup(parseDouble(groupsNode.getAttributes(), "chance"));
|
||||
forEach(groupsNode, "item", itemNode ->
|
||||
{
|
||||
final NamedNodeMap attrs = itemNode.getAttributes();
|
||||
final int id = parseInteger(attrs, "id");
|
||||
final int min = parseInteger(attrs, "min");
|
||||
final int max = parseInteger(attrs, "max");
|
||||
final double chance = parseDouble(attrs, "chance");
|
||||
group.addItem(new EventDropItem(id, min, max, chance));
|
||||
});
|
||||
});
|
||||
rewards.put(name, droplist);
|
||||
break;
|
||||
}
|
||||
case NORMAL:
|
||||
{
|
||||
final NormalDrop droplist = dropType.newInstance();
|
||||
forEach(rewardsNode, "item", itemNode ->
|
||||
{
|
||||
final NamedNodeMap attrs = itemNode.getAttributes();
|
||||
final int id = parseInteger(attrs, "id");
|
||||
final int min = parseInteger(attrs, "min");
|
||||
final int max = parseInteger(attrs, "max");
|
||||
final double chance = parseDouble(attrs, "chance");
|
||||
droplist.addItem(new EventDropItem(id, min, max, chance));
|
||||
});
|
||||
rewards.put(name, droplist);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
eventManager.setRewards(rewards);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param eventManager
|
||||
* @param variables
|
||||
* @param variableNode
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
private void parseListVariables(AbstractEventManager<?> eventManager, StatSet variables, Node variableNode)
|
||||
{
|
||||
final String name = parseString(variableNode.getAttributes(), "name");
|
||||
final String type = parseString(variableNode.getAttributes(), "type");
|
||||
final Class<?> classType = getClassByName(eventManager, type);
|
||||
final List<?> values = newList(classType);
|
||||
switch (type)
|
||||
{
|
||||
case "Byte":
|
||||
case "Short":
|
||||
case "Integer":
|
||||
case "Float":
|
||||
case "Long":
|
||||
case "Double":
|
||||
case "String":
|
||||
{
|
||||
for (Node stringNode = variableNode.getFirstChild(); stringNode != null; stringNode = stringNode.getNextSibling())
|
||||
{
|
||||
if ("value".equals(stringNode.getNodeName()))
|
||||
{
|
||||
((List<Object>) values).add(parseObject(eventManager, type, stringNode.getTextContent()));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "ItemHolder":
|
||||
{
|
||||
for (Node stringNode = variableNode.getFirstChild(); stringNode != null; stringNode = stringNode.getNextSibling())
|
||||
{
|
||||
if ("item".equals(stringNode.getNodeName()))
|
||||
{
|
||||
((List<ItemHolder>) values).add(new ItemHolder(parseInteger(stringNode.getAttributes(), "id"), parseLong(stringNode.getAttributes(), "count", 1L)));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "SkillHolder":
|
||||
{
|
||||
for (Node stringNode = variableNode.getFirstChild(); stringNode != null; stringNode = stringNode.getNextSibling())
|
||||
{
|
||||
if ("skill".equals(stringNode.getNodeName()))
|
||||
{
|
||||
((List<SkillHolder>) values).add(new SkillHolder(parseInteger(stringNode.getAttributes(), "id"), parseInteger(stringNode.getAttributes(), "level", 1)));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "Location":
|
||||
{
|
||||
for (Node stringNode = variableNode.getFirstChild(); stringNode != null; stringNode = stringNode.getNextSibling())
|
||||
{
|
||||
if ("location".equals(stringNode.getNodeName()))
|
||||
{
|
||||
((List<Location>) values).add(new Location(parseInteger(stringNode.getAttributes(), "x"), parseInteger(stringNode.getAttributes(), "y"), parseInteger(stringNode.getAttributes(), "z", parseInteger(stringNode.getAttributes(), "heading", 0))));
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
LOGGER.info(getClass().getSimpleName() + ": Unhandled list case: " + type + " for event: " + eventManager.getClass().getSimpleName());
|
||||
break;
|
||||
}
|
||||
}
|
||||
variables.set(name, values);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param eventManager
|
||||
* @param variables
|
||||
* @param variableNode
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
private void parseMapVariables(AbstractEventManager<?> eventManager, StatSet variables, Node variableNode)
|
||||
{
|
||||
final String name = parseString(variableNode.getAttributes(), "name");
|
||||
final String keyType = parseString(variableNode.getAttributes(), "keyType");
|
||||
final String valueType = parseString(variableNode.getAttributes(), "valueType");
|
||||
final Class<?> keyClass = getClassByName(eventManager, keyType);
|
||||
final Class<?> valueClass = getClassByName(eventManager, valueType);
|
||||
final Map<?, ?> map = newMap(keyClass, valueClass);
|
||||
forEach(variableNode, IXmlReader::isNode, stringNode ->
|
||||
{
|
||||
switch (stringNode.getNodeName())
|
||||
{
|
||||
case "entry":
|
||||
{
|
||||
final NamedNodeMap attrs = stringNode.getAttributes();
|
||||
((Map<Object, Object>) map).put(parseObject(eventManager, keyType, parseString(attrs, "key")), parseObject(eventManager, valueType, parseString(attrs, "value")));
|
||||
break;
|
||||
}
|
||||
case "item":
|
||||
{
|
||||
final NamedNodeMap attrs = stringNode.getAttributes();
|
||||
((Map<Object, ItemHolder>) map).put(parseObject(eventManager, keyType, parseString(attrs, "key")), new ItemHolder(parseInteger(stringNode.getAttributes(), "id"), parseLong(stringNode.getAttributes(), "count")));
|
||||
break;
|
||||
}
|
||||
case "skill":
|
||||
{
|
||||
final NamedNodeMap attrs = stringNode.getAttributes();
|
||||
((Map<Object, SkillHolder>) map).put(parseObject(eventManager, keyType, parseString(attrs, "key")), new SkillHolder(parseInteger(stringNode.getAttributes(), "id"), parseInteger(stringNode.getAttributes(), "level")));
|
||||
break;
|
||||
}
|
||||
case "location":
|
||||
{
|
||||
final NamedNodeMap attrs = stringNode.getAttributes();
|
||||
((Map<Object, Location>) map).put(parseObject(eventManager, keyType, parseString(attrs, "key")), new Location(parseInteger(stringNode.getAttributes(), "x"), parseInteger(stringNode.getAttributes(), "y"), parseInteger(stringNode.getAttributes(), "z", parseInteger(stringNode.getAttributes(), "heading", 0))));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Unhandled map case: " + name + " " + stringNode.getNodeName() + " for event: " + eventManager.getClass().getSimpleName());
|
||||
}
|
||||
}
|
||||
});
|
||||
variables.set(name, map);
|
||||
}
|
||||
|
||||
private Class<?> getClassByName(AbstractEventManager<?> eventManager, String name)
|
||||
{
|
||||
switch (name)
|
||||
{
|
||||
case "Byte":
|
||||
{
|
||||
return Byte.class;
|
||||
}
|
||||
case "Short":
|
||||
{
|
||||
return Short.class;
|
||||
}
|
||||
case "Integer":
|
||||
{
|
||||
return Integer.class;
|
||||
}
|
||||
case "Float":
|
||||
{
|
||||
return Float.class;
|
||||
}
|
||||
case "Long":
|
||||
{
|
||||
return Long.class;
|
||||
}
|
||||
case "Double":
|
||||
{
|
||||
return Double.class;
|
||||
}
|
||||
case "String":
|
||||
{
|
||||
return String.class;
|
||||
}
|
||||
case "ItemHolder":
|
||||
{
|
||||
return ItemHolder.class;
|
||||
}
|
||||
case "SkillHolder":
|
||||
{
|
||||
return SkillHolder.class;
|
||||
}
|
||||
case "Location":
|
||||
{
|
||||
return Location.class;
|
||||
}
|
||||
default:
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Unhandled class case: " + name + " for event: " + eventManager.getClass().getSimpleName());
|
||||
return Object.class;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private Object parseObject(AbstractEventManager<?> eventManager, String type, String value)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case "Byte":
|
||||
{
|
||||
return Byte.decode(value);
|
||||
}
|
||||
case "Short":
|
||||
{
|
||||
return Short.decode(value);
|
||||
}
|
||||
case "Integer":
|
||||
{
|
||||
return Integer.decode(value);
|
||||
}
|
||||
case "Float":
|
||||
{
|
||||
return Float.parseFloat(value);
|
||||
}
|
||||
case "Long":
|
||||
{
|
||||
return Long.decode(value);
|
||||
}
|
||||
case "Double":
|
||||
{
|
||||
return Double.parseDouble(value);
|
||||
}
|
||||
case "String":
|
||||
{
|
||||
return value;
|
||||
}
|
||||
default:
|
||||
{
|
||||
LOGGER.warning(getClass().getSimpleName() + ": Unhandled object case: " + type + " for event: " + eventManager.getClass().getSimpleName());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static <T> List<T> newList(Class<T> type)
|
||||
{
|
||||
return new ArrayList<>();
|
||||
}
|
||||
|
||||
private static <K, V> Map<K, V> newMap(Class<K> keyClass, Class<V> valueClass)
|
||||
{
|
||||
return new LinkedHashMap<>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the single instance of EventEngineData.
|
||||
* @return single instance of EventEngineData
|
||||
*/
|
||||
public static EventEngineData getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final EventEngineData INSTANCE = new EventEngineData();
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.enums;
|
||||
|
||||
import org.l2jmobius.gameserver.model.eventengine.IEventState;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
*/
|
||||
public enum CeremonyOfChaosState implements IEventState
|
||||
{
|
||||
SCHEDULED,
|
||||
REGISTRATION,
|
||||
PREPARING_FOR_TELEPORT,
|
||||
PREPARING_FOR_FIGHT,
|
||||
RUNNING
|
||||
}
|
||||
@@ -1,458 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.instancemanager;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.l2jmobius.commons.database.DatabaseFactory;
|
||||
import org.l2jmobius.commons.util.Rnd;
|
||||
import org.l2jmobius.gameserver.enums.CategoryType;
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosState;
|
||||
import org.l2jmobius.gameserver.model.StatSet;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.actor.Npc;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosMember;
|
||||
import org.l2jmobius.gameserver.model.clan.Clan;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.events.EventType;
|
||||
import org.l2jmobius.gameserver.model.events.ListenerRegisterType;
|
||||
import org.l2jmobius.gameserver.model.events.annotations.RegisterEvent;
|
||||
import org.l2jmobius.gameserver.model.events.annotations.RegisterType;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayerBypass;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayerLogin;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayerLogout;
|
||||
import org.l2jmobius.gameserver.model.events.returns.TerminateReturn;
|
||||
import org.l2jmobius.gameserver.model.olympiad.OlympiadManager;
|
||||
import org.l2jmobius.gameserver.model.punishment.PunishmentAffect;
|
||||
import org.l2jmobius.gameserver.model.punishment.PunishmentType;
|
||||
import org.l2jmobius.gameserver.model.variables.PlayerVariables;
|
||||
import org.l2jmobius.gameserver.model.zone.ZoneId;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseState;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
*/
|
||||
public class CeremonyOfChaosManager extends AbstractEventManager<CeremonyOfChaosEvent>
|
||||
{
|
||||
protected static final Logger LOGGER = Logger.getLogger(CeremonyOfChaosManager.class.getName());
|
||||
|
||||
public static final String INITIAL_BUFF_KEY = "initial_buff";
|
||||
public static final String INITIAL_ITEMS_KEY = "initial_items";
|
||||
public static final String MAX_PLAYERS_KEY = "max_players";
|
||||
public static final String MAX_ARENAS_KEY = "max_arenas";
|
||||
public static final String INSTANCE_TEMPLATES_KEY = "instance_templates";
|
||||
public static final String END_BUFFS_KEYH = "end_buffs";
|
||||
|
||||
protected CeremonyOfChaosManager()
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
if (getState() == null)
|
||||
{
|
||||
setState(CeremonyOfChaosState.SCHEDULED);
|
||||
}
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onPeriodEnd(String text)
|
||||
{
|
||||
// Set monthly true hero.
|
||||
GlobalVariablesManager.getInstance().set(GlobalVariablesManager.COC_TRUE_HERO, GlobalVariablesManager.getInstance().getInt(GlobalVariablesManager.COC_TOP_MEMBER, 0));
|
||||
GlobalVariablesManager.getInstance().set(GlobalVariablesManager.COC_TRUE_HERO_REWARDED, false);
|
||||
// Reset monthly winner.
|
||||
GlobalVariablesManager.getInstance().set(GlobalVariablesManager.COC_TOP_MARKS, 0);
|
||||
GlobalVariablesManager.getInstance().set(GlobalVariablesManager.COC_TOP_MEMBER, 0);
|
||||
|
||||
try (Connection con = DatabaseFactory.getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("DELETE FROM character_variables WHERE var = ?"))
|
||||
{
|
||||
ps.setString(1, PlayerVariables.CEREMONY_OF_CHAOS_MARKS);
|
||||
ps.execute();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.severe(getClass().getSimpleName() + ": Could not reset Ceremony Of Chaos victories: " + e);
|
||||
}
|
||||
|
||||
try (Connection con = DatabaseFactory.getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("DELETE FROM character_variables WHERE var = ?"))
|
||||
{
|
||||
ps.setString(1, PlayerVariables.CEREMONY_OF_CHAOS_PROHIBITED_PENALTIES);
|
||||
ps.execute();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.severe(getClass().getSimpleName() + ": Could not reset Ceremony Of Chaos penalties: " + e);
|
||||
}
|
||||
|
||||
// Update data for online players.
|
||||
for (PlayerInstance player : World.getInstance().getPlayers())
|
||||
{
|
||||
player.getVariables().remove(PlayerVariables.CEREMONY_OF_CHAOS_PROHIBITED_PENALTIES);
|
||||
player.getVariables().remove(PlayerVariables.CEREMONY_OF_CHAOS_MARKS);
|
||||
player.getVariables().storeMe();
|
||||
}
|
||||
|
||||
LOGGER.info(getClass().getSimpleName() + ": Ceremony of Chaos variables have been reset.");
|
||||
LOGGER.info(getClass().getSimpleName() + ": Ceremony of Chaos period has ended!");
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onEventStart()
|
||||
{
|
||||
LOGGER.info(getClass().getSimpleName() + ": Ceremony of Chaos event has started!");
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onEventEnd()
|
||||
{
|
||||
PunishmentManager.getInstance().stopPunishment(PunishmentAffect.CHARACTER, PunishmentType.COC_BAN);
|
||||
LOGGER.info(getClass().getSimpleName() + ": Ceremony of Chaos event has ended!");
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onRegistrationStart()
|
||||
{
|
||||
if (getState() != CeremonyOfChaosState.SCHEDULED)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
setState(CeremonyOfChaosState.REGISTRATION);
|
||||
for (PlayerInstance player : World.getInstance().getPlayers())
|
||||
{
|
||||
if (player.isOnline())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.REGISTRATION_FOR_THE_CEREMONY_OF_CHAOS_HAS_BEGUN);
|
||||
if (canRegister(player, false))
|
||||
{
|
||||
player.sendPacket(ExCuriousHouseState.REGISTRATION_PACKET);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onRegistrationEnd()
|
||||
{
|
||||
if (getState() != CeremonyOfChaosState.REGISTRATION)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
setState(CeremonyOfChaosState.PREPARING_FOR_TELEPORT);
|
||||
for (PlayerInstance player : World.getInstance().getPlayers())
|
||||
{
|
||||
if (player.isOnline())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.REGISTRATION_FOR_THE_CEREMONY_OF_CHAOS_HAS_ENDED);
|
||||
if (!isRegistered(player))
|
||||
{
|
||||
player.sendPacket(ExCuriousHouseState.IDLE_PACKET);
|
||||
}
|
||||
}
|
||||
}
|
||||
final StatSet params = new StatSet();
|
||||
params.set("time", 60);
|
||||
getTimers().addTimer("count_down", params, 60 * 1000, null, null);
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onPrepareForFight()
|
||||
{
|
||||
if (getState() != CeremonyOfChaosState.PREPARING_FOR_TELEPORT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
setState(CeremonyOfChaosState.PREPARING_FOR_FIGHT);
|
||||
int eventId = 0;
|
||||
int position = 1;
|
||||
CeremonyOfChaosEvent event = null;
|
||||
final List<PlayerInstance> players = getRegisteredPlayers().stream().sorted(Comparator.comparingInt(PlayerInstance::getLevel)).collect(Collectors.toList());
|
||||
final int maxPlayers = getMaxPlayersInArena();
|
||||
final List<Integer> templates = getVariables().getList(INSTANCE_TEMPLATES_KEY, Integer.class);
|
||||
for (PlayerInstance player : players)
|
||||
{
|
||||
if (player.isOnline() && canRegister(player, true))
|
||||
{
|
||||
if ((event == null) || (event.getMembers().size() >= maxPlayers))
|
||||
{
|
||||
final int template = templates.get(Rnd.get(templates.size()));
|
||||
event = new CeremonyOfChaosEvent(eventId++, InstanceManager.getInstance().getInstanceTemplate(template));
|
||||
position = 1;
|
||||
getEvents().add(event);
|
||||
}
|
||||
|
||||
event.addMember(new CeremonyOfChaosMember(player, event, position++));
|
||||
}
|
||||
else
|
||||
{
|
||||
player.prohibiteCeremonyOfChaos();
|
||||
player.sendPacket(ExCuriousHouseState.IDLE_PACKET);
|
||||
}
|
||||
}
|
||||
|
||||
// Clear previously registrated players
|
||||
getRegisteredPlayers().clear();
|
||||
|
||||
// Prepare all event's players for start
|
||||
getEvents().forEach(CeremonyOfChaosEvent::preparePlayers);
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onStartFight()
|
||||
{
|
||||
if (getState() != CeremonyOfChaosState.PREPARING_FOR_FIGHT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
setState(CeremonyOfChaosState.RUNNING);
|
||||
getEvents().forEach(CeremonyOfChaosEvent::startFight);
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onEndFight()
|
||||
{
|
||||
if (getState() != CeremonyOfChaosState.RUNNING)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
setState(CeremonyOfChaosState.SCHEDULED);
|
||||
getEvents().forEach(CeremonyOfChaosEvent::stopFight);
|
||||
getEvents().clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onTimerEvent(String event, StatSet params, Npc npc, PlayerInstance player)
|
||||
{
|
||||
switch (event)
|
||||
{
|
||||
case "count_down":
|
||||
{
|
||||
final int time = params.getInt("time", 0);
|
||||
final SystemMessage countdown = new SystemMessage(SystemMessageId.YOU_WILL_BE_MOVED_TO_THE_ARENA_IN_S1_SECOND_S);
|
||||
countdown.addByte(time);
|
||||
broadcastPacket(countdown);
|
||||
|
||||
// Reschedule
|
||||
if (time == 60)
|
||||
{
|
||||
params.set("time", 10);
|
||||
getTimers().addTimer(event, params, 50 * 1000, null, null);
|
||||
}
|
||||
else if (time == 10)
|
||||
{
|
||||
params.set("time", 5);
|
||||
getTimers().addTimer(event, params, 5 * 1000, null, null);
|
||||
}
|
||||
else if ((time > 1) && (time <= 5))
|
||||
{
|
||||
params.set("time", time - 1);
|
||||
getTimers().addTimer(event, params, 1000, null, null);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void broadcastPacket(IClientOutgoingPacket... packets)
|
||||
{
|
||||
getRegisteredPlayers().forEach(member -> member.sendPacket(packets));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canRegister(PlayerInstance player, boolean sendMessage)
|
||||
{
|
||||
boolean canRegister = true;
|
||||
|
||||
final Clan clan = player.getClan();
|
||||
SystemMessageId sm = null;
|
||||
if (player.getLevel() < 85)
|
||||
{
|
||||
sm = SystemMessageId.ONLY_CHARACTERS_LEVEL_85_OR_ABOVE_MAY_PARTICIPATE_IN_THE_TOURNAMENT;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isFlyingMounted())
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_PARTICIPATE_IN_THE_CEREMONY_OF_CHAOS_AS_A_FLYING_TRANSFORMED_OBJECT;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (!player.isInCategory(CategoryType.SIXTH_CLASS_GROUP))
|
||||
{
|
||||
sm = SystemMessageId.ONLY_CHARACTERS_WHO_HAVE_COMPLETED_THE_3RD_CLASS_TRANSFER_MAY_PARTICIPATE;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (!player.isInventoryUnder80(false) || (player.getWeightPenalty() != 0))
|
||||
{
|
||||
sm = SystemMessageId.UNABLE_TO_PROCESS_THIS_REQUEST_UNTIL_YOUR_INVENTORY_S_WEIGHT_AND_SLOT_COUNT_ARE_LESS_THAN_80_PERCENT_OF_CAPACITY;
|
||||
canRegister = false;
|
||||
}
|
||||
else if ((clan == null) || (clan.getLevel() < 6))
|
||||
{
|
||||
sm = SystemMessageId.ONLY_CHARACTERS_WHO_ARE_A_PART_OF_A_CLAN_OF_LEVEL_6_OR_ABOVE_MAY_PARTICIPATE;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (getRegisteredPlayers().size() >= (getVariables().getInt(MAX_ARENAS_KEY, 5) * getMaxPlayersInArena()))
|
||||
{
|
||||
sm = SystemMessageId.THERE_ARE_TOO_MANY_CHALLENGERS_YOU_CANNOT_PARTICIPATE_NOW;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isCursedWeaponEquipped() || (player.getReputation() < 0))
|
||||
{
|
||||
sm = SystemMessageId.WAITING_LIST_REGISTRATION_IS_NOT_ALLOWED_WHILE_THE_CURSED_SWORD_IS_BEING_USED_OR_THE_STATUS_IS_IN_A_CHAOTIC_STATE;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isInDuel())
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_REGISTER_IN_THE_WAITING_LIST_DURING_A_DUEL;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isInOlympiadMode() || OlympiadManager.getInstance().isRegistered(player))
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_REGISTER_IN_THE_WAITING_LIST_WHILE_PARTICIPATING_IN_OLYMPIAD;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isOnEvent(CeremonyOfChaosEvent.class) || (player.getBlockCheckerArena() > -1)) // TODO underground coliseum and kratei checks.
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_REGISTER_FOR_THE_WAITING_LIST_WHILE_PARTICIPATING_IN_THE_BLOCK_CHECKER_COLISEUM_OLYMPIAD_KRATEI_S_CUBE_CEREMONY_OF_CHAOS;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isInInstance())
|
||||
{
|
||||
sm = SystemMessageId.YOU_MAY_NOT_REGISTER_WHILE_USING_THE_INSTANT_ZONE;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isInSiege())
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_REGISTER_FOR_THE_WAITING_LIST_ON_THE_BATTLEFIELD_CASTLE_SIEGE_FORTRESS_SIEGE;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isInsideZone(ZoneId.SIEGE))
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_REGISTER_IN_THE_WAITING_LIST_WHILE_BEING_INSIDE_OF_A_BATTLEGROUND_CASTLE_SIEGE_FORTRESS_SIEGE;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isFlyingMounted())
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_PARTICIPATE_IN_THE_CEREMONY_OF_CHAOS_AS_A_FLYING_TRANSFORMED_OBJECT;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isFishing())
|
||||
{
|
||||
sm = SystemMessageId.YOU_CANNOT_PARTICIPATE_IN_THE_CEREMONY_OF_CHAOS_WHILE_FISHING;
|
||||
canRegister = false;
|
||||
}
|
||||
else if (player.isCeremonyOfChaosProhibited())
|
||||
{
|
||||
canRegister = false;
|
||||
}
|
||||
|
||||
// TODO : One player can take part in 16 matches per day.
|
||||
if ((sm != null) && sendMessage)
|
||||
{
|
||||
player.sendPacket(sm);
|
||||
}
|
||||
|
||||
return canRegister;
|
||||
}
|
||||
|
||||
@RegisterEvent(EventType.ON_PLAYER_BYPASS)
|
||||
@RegisterType(ListenerRegisterType.GLOBAL_PLAYERS)
|
||||
public TerminateReturn OnPlayerBypass(OnPlayerBypass event)
|
||||
{
|
||||
final PlayerInstance player = event.getPlayer();
|
||||
if (player == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (event.getCommand().equalsIgnoreCase("pledgegame?command=apply"))
|
||||
{
|
||||
if (registerPlayer(player))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_ARE_NOW_ON_THE_WAITING_LIST_YOU_WILL_AUTOMATICALLY_BE_TELEPORTED_WHEN_THE_TOURNAMENT_STARTS_AND_WILL_BE_REMOVED_FROM_THE_WAITING_LIST_IF_YOU_LOG_OUT_IF_YOU_CANCEL_REGISTRATION_WITHIN_THE_LAST_MINUTE_OF_ENTERING_THE_ARENA_AFTER_SIGNING_UP_30_TIMES_OR_MORE_OR_FORFEIT_AFTER_ENTERING_THE_ARENA_30_TIMES_OR_MORE_DURING_A_CYCLE_YOU_BECOME_INELIGIBLE_FOR_PARTICIPATION_IN_THE_CEREMONY_OF_CHAOS_UNTIL_THE_NEXT_CYCLE_ALL_THE_BUFFS_EXCEPT_THE_VITALITY_BUFF_WILL_BE_REMOVED_ONCE_YOU_ENTER_THE_ARENAS);
|
||||
player.sendPacket(SystemMessageId.EXCEPT_THE_VITALITY_BUFF_ALL_BUFFS_INCLUDING_ART_OF_SEDUCTION_WILL_BE_DELETED);
|
||||
player.sendPacket(ExCuriousHouseState.PREPARE_PACKET);
|
||||
}
|
||||
return new TerminateReturn(true, false, false);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@RegisterEvent(EventType.ON_PLAYER_LOGIN)
|
||||
@RegisterType(ListenerRegisterType.GLOBAL_PLAYERS)
|
||||
public void OnPlayerLogin(OnPlayerLogin event)
|
||||
{
|
||||
if (getState() == CeremonyOfChaosState.REGISTRATION)
|
||||
{
|
||||
final PlayerInstance player = event.getPlayer();
|
||||
if (canRegister(player, false))
|
||||
{
|
||||
player.sendPacket(ExCuriousHouseState.REGISTRATION_PACKET);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@RegisterEvent(EventType.ON_PLAYER_LOGOUT)
|
||||
@RegisterType(ListenerRegisterType.GLOBAL)
|
||||
public void OnPlayerLogout(OnPlayerLogout event)
|
||||
{
|
||||
if (getState() == CeremonyOfChaosState.REGISTRATION)
|
||||
{
|
||||
final PlayerInstance player = event.getPlayer();
|
||||
if (getRegisteredPlayers().contains(player))
|
||||
{
|
||||
getRegisteredPlayers().remove(player);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// player leave clan
|
||||
|
||||
public int getMaxPlayersInArena()
|
||||
{
|
||||
return getVariables().getInt(MAX_PLAYERS_KEY, 18);
|
||||
}
|
||||
|
||||
public static CeremonyOfChaosManager getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final CeremonyOfChaosManager INSTANCE = new CeremonyOfChaosManager();
|
||||
}
|
||||
}
|
||||
@@ -16,56 +16,77 @@
|
||||
*/
|
||||
package org.l2jmobius.gameserver.instancemanager;
|
||||
|
||||
import java.util.Calendar;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.concurrent.ScheduledFuture;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.l2jmobius.commons.threads.ThreadPool;
|
||||
import org.l2jmobius.commons.util.Chronos;
|
||||
import org.l2jmobius.gameserver.data.xml.ClanHallData;
|
||||
import org.l2jmobius.gameserver.model.clan.Clan;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.residences.ClanHallAuction;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
*/
|
||||
public class ClanHallAuctionManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
public class ClanHallAuctionManager
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(ClanHallAuctionManager.class.getName());
|
||||
|
||||
private static final Map<Integer, ClanHallAuction> AUCTIONS = new HashMap<>();
|
||||
private static ScheduledFuture<?> _endTask;
|
||||
|
||||
protected ClanHallAuctionManager()
|
||||
{
|
||||
// Schedule of the start, next Wednesday at 19:00.
|
||||
final Calendar start = Calendar.getInstance();
|
||||
if ((start.get(Calendar.DAY_OF_WEEK) >= Calendar.WEDNESDAY))
|
||||
{
|
||||
start.add(Calendar.DAY_OF_YEAR, 7);
|
||||
}
|
||||
start.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
|
||||
start.set(Calendar.HOUR_OF_DAY, 19);
|
||||
start.set(Calendar.MINUTE, 0);
|
||||
start.set(Calendar.SECOND, 0);
|
||||
final long startDelay = Math.max(0, start.getTimeInMillis() - Chronos.currentTimeMillis());
|
||||
ThreadPool.scheduleAtFixedRate(() -> onStart(), startDelay, 604800000); // 604800000 = 1 week
|
||||
if (startDelay > 0)
|
||||
{
|
||||
onStart();
|
||||
}
|
||||
|
||||
// Schedule of the end, next Wednesday at 11:00.
|
||||
final Calendar end = Calendar.getInstance();
|
||||
if ((end.get(Calendar.DAY_OF_WEEK) >= Calendar.WEDNESDAY))
|
||||
{
|
||||
end.add(Calendar.DAY_OF_YEAR, 7);
|
||||
}
|
||||
end.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
|
||||
end.set(Calendar.HOUR_OF_DAY, 11);
|
||||
end.set(Calendar.MINUTE, 0);
|
||||
end.set(Calendar.SECOND, 0);
|
||||
final long endDelay = Math.max(0, end.getTimeInMillis() - Chronos.currentTimeMillis());
|
||||
_endTask = ThreadPool.scheduleAtFixedRate(() -> onEnd(), endDelay, 604800000); // 604800000 = 1 week
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onEventStart()
|
||||
private void onStart()
|
||||
{
|
||||
LOGGER.info(getClass().getSimpleName() + ": Clan Hall Auction has started!");
|
||||
AUCTIONS.clear();
|
||||
|
||||
//@formatter:off
|
||||
ClanHallData.getInstance().getFreeAuctionableHall()
|
||||
.forEach(c -> AUCTIONS.put(c.getResidenceId(), new ClanHallAuction(c.getResidenceId())));
|
||||
//@formatter:on
|
||||
ClanHallData.getInstance().getFreeAuctionableHall().forEach(c -> AUCTIONS.put(c.getResidenceId(), new ClanHallAuction(c.getResidenceId())));
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onEventEnd()
|
||||
private void onEnd()
|
||||
{
|
||||
AUCTIONS.values().forEach(ClanHallAuction::finalizeAuctions);
|
||||
AUCTIONS.clear();
|
||||
LOGGER.info(getClass().getSimpleName() + ": Clan Hall Auction has ended!");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
}
|
||||
|
||||
public ClanHallAuction getClanHallAuctionById(int clanHallId)
|
||||
{
|
||||
return AUCTIONS.get(clanHallId);
|
||||
@@ -95,6 +116,11 @@ public class ClanHallAuctionManager extends AbstractEventManager<AbstractEvent<?
|
||||
return false;
|
||||
}
|
||||
|
||||
public long getRemainingTime()
|
||||
{
|
||||
return _endTask.getDelay(TimeUnit.MILLISECONDS);
|
||||
}
|
||||
|
||||
public static ClanHallAuctionManager getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
|
||||
@@ -18,13 +18,14 @@ package org.l2jmobius.gameserver.instancemanager;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Calendar;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.l2jmobius.Config;
|
||||
import org.l2jmobius.commons.database.DatabaseFactory;
|
||||
import org.l2jmobius.commons.threads.ThreadPool;
|
||||
import org.l2jmobius.commons.util.Chronos;
|
||||
import org.l2jmobius.gameserver.data.sql.ClanTable;
|
||||
import org.l2jmobius.gameserver.data.xml.DailyMissionData;
|
||||
import org.l2jmobius.gameserver.model.DailyMissionDataHolder;
|
||||
@@ -33,10 +34,6 @@ import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.actor.stat.PlayerStat;
|
||||
import org.l2jmobius.gameserver.model.clan.Clan;
|
||||
import org.l2jmobius.gameserver.model.clan.ClanMember;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.holders.SkillHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.SubClassHolder;
|
||||
import org.l2jmobius.gameserver.model.olympiad.Olympiad;
|
||||
import org.l2jmobius.gameserver.model.variables.PlayerVariables;
|
||||
@@ -46,32 +43,55 @@ import org.l2jmobius.gameserver.network.serverpackets.ExWorldChatCnt;
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class DailyTaskManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
public class DailyTaskManager
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(DailyTaskManager.class.getName());
|
||||
|
||||
private final static int[] RESET_SKILLS =
|
||||
{
|
||||
2510, // Wondrous Cubic
|
||||
22180, // Wondrous Cubic - 1 time use
|
||||
};
|
||||
|
||||
protected DailyTaskManager()
|
||||
{
|
||||
// Schedule reset everyday at 6:30.
|
||||
final Calendar calendar = Calendar.getInstance();
|
||||
if ((calendar.get(Calendar.HOUR_OF_DAY) > 6) && (calendar.get(Calendar.MINUTE) > 30))
|
||||
{
|
||||
calendar.add(Calendar.DAY_OF_YEAR, 1);
|
||||
}
|
||||
calendar.set(Calendar.HOUR_OF_DAY, 6);
|
||||
calendar.set(Calendar.MINUTE, 30);
|
||||
calendar.set(Calendar.SECOND, 0);
|
||||
final long startDelay = Math.max(0, calendar.getTimeInMillis() - Chronos.currentTimeMillis());
|
||||
ThreadPool.scheduleAtFixedRate(() -> onReset(), startDelay, 86400000); // 86400000 = 1 day
|
||||
|
||||
// Global save task.
|
||||
ThreadPool.scheduleAtFixedRate(() -> onSave(), 1800000, 1800000); // 1800000 = 30 minutes
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onReset()
|
||||
{
|
||||
if (Calendar.getInstance().get(Calendar.DAY_OF_WEEK) == Calendar.WEDNESDAY)
|
||||
{
|
||||
clanLeaderApply();
|
||||
resetVitalityWeekly();
|
||||
}
|
||||
else
|
||||
{
|
||||
resetVitalityDaily();
|
||||
}
|
||||
|
||||
resetClanBonus();
|
||||
resetDailyMissionRewards();
|
||||
resetDailySkills();
|
||||
resetRecommends();
|
||||
resetWorldChatPoints();
|
||||
resetRecommends();
|
||||
resetTrainingCamp();
|
||||
onResetAttendanceRewards();
|
||||
resetDailyMissionRewards();
|
||||
resetAttendanceRewards();
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onSave()
|
||||
{
|
||||
GlobalVariablesManager.getInstance().storeMe();
|
||||
@@ -83,8 +103,7 @@ public class DailyTaskManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
}
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onClanLeaderApply()
|
||||
private void clanLeaderApply()
|
||||
{
|
||||
for (Clan clan : ClanTable.getInstance().getClans())
|
||||
{
|
||||
@@ -102,8 +121,49 @@ public class DailyTaskManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
LOGGER.info("Clan leaders has been updated.");
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
private void onVitalityReset()
|
||||
private void resetVitalityDaily()
|
||||
{
|
||||
if (!Config.ENABLE_VITALITY)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int vitality = PlayerStat.MAX_VITALITY_POINTS / 4;
|
||||
for (PlayerInstance player : World.getInstance().getPlayers())
|
||||
{
|
||||
final int VP = player.getVitalityPoints();
|
||||
player.setVitalityPoints(VP + vitality, false);
|
||||
for (SubClassHolder subclass : player.getSubClasses().values())
|
||||
{
|
||||
final int VPS = subclass.getVitalityPoints();
|
||||
subclass.setVitalityPoints(VPS + vitality);
|
||||
}
|
||||
}
|
||||
|
||||
try (Connection con = DatabaseFactory.getConnection())
|
||||
{
|
||||
try (PreparedStatement st = con.prepareStatement("UPDATE character_subclasses SET vitality_points = IF(vitality_points = ?, vitality_points, vitality_points + ?)"))
|
||||
{
|
||||
st.setInt(1, PlayerStat.MAX_VITALITY_POINTS);
|
||||
st.setInt(2, PlayerStat.MAX_VITALITY_POINTS / 4);
|
||||
st.execute();
|
||||
}
|
||||
|
||||
try (PreparedStatement st = con.prepareStatement("UPDATE characters SET vitality_points = IF(vitality_points = ?, vitality_points, vitality_points + ?)"))
|
||||
{
|
||||
st.setInt(1, PlayerStat.MAX_VITALITY_POINTS);
|
||||
st.setInt(2, PlayerStat.MAX_VITALITY_POINTS / 4);
|
||||
st.execute();
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "Error while updating vitality", e);
|
||||
}
|
||||
LOGGER.info("Daily Vitality Added");
|
||||
}
|
||||
|
||||
private void resetVitalityWeekly()
|
||||
{
|
||||
if (!Config.ENABLE_VITALITY)
|
||||
{
|
||||
@@ -150,12 +210,11 @@ public class DailyTaskManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
{
|
||||
try (Connection con = DatabaseFactory.getConnection())
|
||||
{
|
||||
final List<SkillHolder> dailySkills = getVariables().getList("reset_skills", SkillHolder.class, Collections.emptyList());
|
||||
for (SkillHolder skill : dailySkills)
|
||||
for (int skill : RESET_SKILLS)
|
||||
{
|
||||
try (PreparedStatement ps = con.prepareStatement("DELETE FROM character_skills_save WHERE skill_id=?;"))
|
||||
{
|
||||
ps.setInt(1, skill.getSkillId());
|
||||
ps.setInt(1, skill);
|
||||
ps.execute();
|
||||
}
|
||||
}
|
||||
@@ -260,7 +319,7 @@ public class DailyTaskManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
DailyMissionData.getInstance().getDailyMissionData().forEach(DailyMissionDataHolder::reset);
|
||||
}
|
||||
|
||||
public void onResetAttendanceRewards()
|
||||
public void resetAttendanceRewards()
|
||||
{
|
||||
if (Config.ATTENDANCE_REWARDS_SHARE_ACCOUNT)
|
||||
{
|
||||
|
||||
@@ -168,9 +168,9 @@ public class HandysBlockCheckerManager
|
||||
return false;
|
||||
}
|
||||
|
||||
if (player.isOnEvent() || player.isInOlympiadMode())
|
||||
if (player.isRegisteredOnEvent() || player.isInOlympiadMode())
|
||||
{
|
||||
player.sendMessage("Couldnt register you due other event participation");
|
||||
player.sendMessage("Couldnt register you due other event participation.");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@@ -401,12 +401,7 @@ public class SellBuffsManager implements IXmlReader
|
||||
player.sendMessage("You can't sell buffs with Olympiad status!");
|
||||
return false;
|
||||
}
|
||||
else if (CeremonyOfChaosManager.getInstance().isRegistered(player))
|
||||
{
|
||||
player.sendMessage("You can't sell buffs with Ceremony of Chaos status!");
|
||||
return false;
|
||||
}
|
||||
else if (player.isOnEvent()) // custom event message
|
||||
else if (player.isRegisteredOnEvent())
|
||||
{
|
||||
player.sendMessage("You can't sell buffs while registered in an event!");
|
||||
return false;
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.instancemanager.events;
|
||||
|
||||
import org.l2jmobius.gameserver.instancemanager.QuestManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.quest.Event;
|
||||
|
||||
/**
|
||||
* @author Mobius
|
||||
*/
|
||||
public class ElpiesManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
{
|
||||
protected ElpiesManager()
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
protected void startEvent()
|
||||
{
|
||||
final Event event = (Event) QuestManager.getInstance().getQuest("Elpies");
|
||||
if (event != null)
|
||||
{
|
||||
event.eventStart(null);
|
||||
}
|
||||
}
|
||||
|
||||
public static ElpiesManager getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final ElpiesManager INSTANCE = new ElpiesManager();
|
||||
}
|
||||
}
|
||||
@@ -1,548 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.instancemanager.events;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.FileReader;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.l2jmobius.Config;
|
||||
import org.l2jmobius.gameserver.cache.HtmCache;
|
||||
import org.l2jmobius.gameserver.data.SpawnTable;
|
||||
import org.l2jmobius.gameserver.data.xml.NpcData;
|
||||
import org.l2jmobius.gameserver.instancemanager.AntiFeedManager;
|
||||
import org.l2jmobius.gameserver.model.Spawn;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.actor.Npc;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.holders.PlayerEventHolder;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.MagicSkillUse;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.NpcHtmlMessage;
|
||||
|
||||
/**
|
||||
* @author Nik
|
||||
* @Since 2011/05/17 21:51:39
|
||||
*/
|
||||
public class GameEvent
|
||||
{
|
||||
protected static final Logger LOGGER = Logger.getLogger(GameEvent.class.getName());
|
||||
public static EventState eventState = EventState.OFF;
|
||||
public static String _eventName = "";
|
||||
public static String _eventCreator = "";
|
||||
public static String _eventInfo = "";
|
||||
public static int _teamsNumber = 0;
|
||||
public static final Map<Integer, String> _teamNames = new ConcurrentHashMap<>();
|
||||
public static final Set<PlayerInstance> _registeredPlayers = ConcurrentHashMap.newKeySet();
|
||||
public static final Map<Integer, Set<PlayerInstance>> _teams = new ConcurrentHashMap<>();
|
||||
public static int _npcId = 0;
|
||||
private static final Map<PlayerInstance, PlayerEventHolder> _connectionLossData = new ConcurrentHashMap<>();
|
||||
|
||||
public enum EventState
|
||||
{
|
||||
OFF, // Not running
|
||||
STANDBY, // Waiting for participants to register
|
||||
ON // Registration is over and the event has started.
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player
|
||||
* @return The team ID where the player is in, or -1 if player is null or team not found.
|
||||
*/
|
||||
public static int getPlayerTeamId(PlayerInstance player)
|
||||
{
|
||||
if (player == null)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (Entry<Integer, Set<PlayerInstance>> team : _teams.entrySet())
|
||||
{
|
||||
if (team.getValue().contains(player))
|
||||
{
|
||||
return team.getKey();
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
public static List<PlayerInstance> getTopNKillers(int n)
|
||||
{
|
||||
final Map<PlayerInstance, Integer> tmp = new HashMap<>();
|
||||
for (Set<PlayerInstance> teamList : _teams.values())
|
||||
{
|
||||
for (PlayerInstance player : teamList)
|
||||
{
|
||||
if (player.getEventStatus() == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
tmp.put(player, player.getEventStatus().getKills().size());
|
||||
}
|
||||
}
|
||||
|
||||
sortByValue(tmp);
|
||||
|
||||
// If the map size is less than "n", n will be as much as the map size
|
||||
if (tmp.size() <= n)
|
||||
{
|
||||
return new ArrayList<>(tmp.keySet());
|
||||
}
|
||||
|
||||
final List<PlayerInstance> toReturn = new ArrayList<>(tmp.keySet());
|
||||
return toReturn.subList(1, n);
|
||||
}
|
||||
|
||||
public static void showEventHtml(PlayerInstance player, String objectid)
|
||||
{
|
||||
// TODO: work on this
|
||||
if (eventState == EventState.STANDBY)
|
||||
{
|
||||
try
|
||||
{
|
||||
final String htmContent;
|
||||
final NpcHtmlMessage html = new NpcHtmlMessage(Integer.parseInt(objectid));
|
||||
if (_registeredPlayers.contains(player))
|
||||
{
|
||||
htmContent = HtmCache.getInstance().getHtm(player, "data/html/mods/EventEngine/Participating.htm");
|
||||
}
|
||||
else
|
||||
{
|
||||
htmContent = HtmCache.getInstance().getHtm(player, "data/html/mods/EventEngine/Participation.htm");
|
||||
}
|
||||
|
||||
if (htmContent != null)
|
||||
{
|
||||
html.setHtml(htmContent);
|
||||
}
|
||||
|
||||
html.replace("%objectId%", objectid); // Yeah, we need this.
|
||||
html.replace("%eventName%", _eventName);
|
||||
html.replace("%eventCreator%", _eventCreator);
|
||||
html.replace("%eventInfo%", _eventInfo);
|
||||
player.sendPacket(html);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "Exception on showEventHtml(): " + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Spawns an event participation NPC near the player. The npc id used to spawning is GameEvent._npcId
|
||||
* @param target
|
||||
*/
|
||||
public static void spawnEventNpc(PlayerInstance target)
|
||||
{
|
||||
try
|
||||
{
|
||||
final Spawn spawn = new Spawn(_npcId);
|
||||
spawn.setXYZ(target.getX() + 50, target.getY() + 50, target.getZ());
|
||||
spawn.setAmount(1);
|
||||
spawn.setHeading(target.getHeading());
|
||||
spawn.stopRespawn();
|
||||
SpawnTable.getInstance().addNewSpawn(spawn, false);
|
||||
spawn.init();
|
||||
spawn.getLastSpawn().setCurrentHp(999999999);
|
||||
spawn.getLastSpawn().setTitle(_eventName);
|
||||
spawn.getLastSpawn().getVariables().set("eventmob", true);
|
||||
spawn.getLastSpawn().setInvul(true);
|
||||
// spawn.getLastSpawn().decayMe();
|
||||
// spawn.getLastSpawn().spawnMe(spawn.getLastSpawn().getX(), spawn.getLastSpawn().getY(), spawn.getLastSpawn().getZ());
|
||||
spawn.getLastSpawn().broadcastPacket(new MagicSkillUse(spawn.getLastSpawn(), spawn.getLastSpawn(), 1034, 1, 1, 1));
|
||||
|
||||
// _npcs.add(spawn.getLastSpawn());
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "Exception on spawn(): " + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Zoey76: TODO: Rewrite this in a way that doesn't iterate over all spawns.
|
||||
*/
|
||||
public static void unspawnEventNpcs()
|
||||
{
|
||||
SpawnTable.getInstance().forEachSpawn(spawn ->
|
||||
{
|
||||
final Npc npc = spawn.getLastSpawn();
|
||||
if ((npc != null) && npc.getVariables().getBoolean("eventmob", false))
|
||||
{
|
||||
npc.deleteMe();
|
||||
spawn.stopRespawn();
|
||||
SpawnTable.getInstance().deleteSpawn(spawn, false);
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player
|
||||
* @return False: If player is null, his event status is null or the event state is off. True: if the player is inside the _registeredPlayers list while the event state is STANDBY. If the event state is ON, it will check if the player is inside in one of the teams.
|
||||
*/
|
||||
public static boolean isParticipant(PlayerInstance player)
|
||||
{
|
||||
if ((player == null) || (player.getEventStatus() == null))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (eventState)
|
||||
{
|
||||
case OFF:
|
||||
{
|
||||
return false;
|
||||
}
|
||||
case STANDBY:
|
||||
{
|
||||
return _registeredPlayers.contains(player);
|
||||
}
|
||||
case ON:
|
||||
{
|
||||
for (Set<PlayerInstance> teamList : _teams.values())
|
||||
{
|
||||
if (teamList.contains(player))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the player to the list of participants. If the event state is NOT STANDBY, the player wont be registered.
|
||||
* @param player
|
||||
*/
|
||||
public static void registerPlayer(PlayerInstance player)
|
||||
{
|
||||
if (eventState != EventState.STANDBY)
|
||||
{
|
||||
player.sendMessage("The registration period for this event is over.");
|
||||
return;
|
||||
}
|
||||
|
||||
if ((Config.DUALBOX_CHECK_MAX_L2EVENT_PARTICIPANTS_PER_IP == 0) || AntiFeedManager.getInstance().tryAddPlayer(AntiFeedManager.L2EVENT_ID, player, Config.DUALBOX_CHECK_MAX_L2EVENT_PARTICIPANTS_PER_IP))
|
||||
{
|
||||
_registeredPlayers.add(player);
|
||||
}
|
||||
else
|
||||
{
|
||||
player.sendMessage("You have reached the maximum allowed participants per IP.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the player from the participating players and the teams and restores his init stats before he registered at the event (loc, pvp, pk, title etc)
|
||||
* @param player
|
||||
*/
|
||||
public static void removeAndResetPlayer(PlayerInstance player)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (isParticipant(player))
|
||||
{
|
||||
if (player.isDead())
|
||||
{
|
||||
player.restoreExp(100.0);
|
||||
player.doRevive();
|
||||
player.setCurrentHpMp(player.getMaxHp(), player.getMaxMp());
|
||||
player.setCurrentCp(player.getMaxCp());
|
||||
}
|
||||
|
||||
player.decayMe();
|
||||
player.spawnMe(player.getX(), player.getY(), player.getZ());
|
||||
player.broadcastUserInfo();
|
||||
|
||||
player.stopTransformation(true);
|
||||
}
|
||||
|
||||
if (player.getEventStatus() != null)
|
||||
{
|
||||
player.getEventStatus().restorePlayerStats();
|
||||
}
|
||||
|
||||
player.setEventStatus(null);
|
||||
|
||||
_registeredPlayers.remove(player);
|
||||
final int teamId = getPlayerTeamId(player);
|
||||
if (_teams.containsKey(teamId))
|
||||
{
|
||||
_teams.get(teamId).remove(player);
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "Error at unregisterAndResetPlayer in the event:" + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The player's event status will be saved at _connectionLossData
|
||||
* @param player
|
||||
*/
|
||||
public static void savePlayerEventStatus(PlayerInstance player)
|
||||
{
|
||||
_connectionLossData.put(player, player.getEventStatus());
|
||||
}
|
||||
|
||||
/**
|
||||
* If _connectionLossData contains the player, it will restore the player's event status. Also it will remove the player from the _connectionLossData.
|
||||
* @param player
|
||||
*/
|
||||
public static void restorePlayerEventStatus(PlayerInstance player)
|
||||
{
|
||||
if (_connectionLossData.containsKey(player))
|
||||
{
|
||||
player.setEventStatus(_connectionLossData.get(player));
|
||||
_connectionLossData.remove(player);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If the event is ON or STANDBY, it will not start. Sets the event state to STANDBY and spawns registration NPCs
|
||||
* @return a string with information if the event participation has been successfully started or not.
|
||||
*/
|
||||
public static String startEventParticipation()
|
||||
{
|
||||
try
|
||||
{
|
||||
switch (eventState)
|
||||
{
|
||||
case ON:
|
||||
{
|
||||
return "Cannot start event, it is already on.";
|
||||
}
|
||||
case STANDBY:
|
||||
{
|
||||
return "Cannot start event, it is on standby mode.";
|
||||
}
|
||||
case OFF: // Event is off, so no problem turning it on.
|
||||
{
|
||||
eventState = EventState.STANDBY;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Register the event at AntiFeedManager and clean it for just in case if the event is already registered.
|
||||
AntiFeedManager.getInstance().registerEvent(AntiFeedManager.L2EVENT_ID);
|
||||
AntiFeedManager.getInstance().clear(AntiFeedManager.L2EVENT_ID);
|
||||
|
||||
// Just in case
|
||||
unspawnEventNpcs();
|
||||
_registeredPlayers.clear();
|
||||
// _npcs.clear();
|
||||
if (NpcData.getInstance().getTemplate(_npcId) == null)
|
||||
{
|
||||
return "Cannot start event, invalid npc id.";
|
||||
}
|
||||
|
||||
try (FileReader fr = new FileReader(Config.DATAPACK_ROOT + "/data/events/" + _eventName);
|
||||
BufferedReader br = new BufferedReader(fr))
|
||||
{
|
||||
_eventCreator = br.readLine();
|
||||
_eventInfo = br.readLine();
|
||||
}
|
||||
|
||||
final Set<PlayerInstance> temp = new HashSet<>();
|
||||
for (PlayerInstance player : World.getInstance().getPlayers())
|
||||
{
|
||||
if (!player.isOnline())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!temp.contains(player))
|
||||
{
|
||||
spawnEventNpc(player);
|
||||
temp.add(player);
|
||||
}
|
||||
|
||||
World.getInstance().forEachVisibleObjectInRange(player, PlayerInstance.class, 1000, temp::add);
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.warning("Event: " + e.getMessage());
|
||||
return "Cannot start event participation, an error has occured.";
|
||||
}
|
||||
|
||||
return "The event participation has been successfully started.";
|
||||
}
|
||||
|
||||
/**
|
||||
* If the event is ON or OFF, it will not start. Sets the event state to ON, creates the teams, adds the registered players ordered by level at the teams and adds a new event status to the players.
|
||||
* @return a string with information if the event has been successfully started or not.
|
||||
*/
|
||||
public static String startEvent()
|
||||
{
|
||||
try
|
||||
{
|
||||
switch (eventState)
|
||||
{
|
||||
case ON:
|
||||
{
|
||||
return "Cannot start event, it is already on.";
|
||||
}
|
||||
case STANDBY:
|
||||
{
|
||||
eventState = EventState.ON;
|
||||
break;
|
||||
}
|
||||
case OFF: // Event is off, so no problem turning it on.
|
||||
{
|
||||
return "Cannot start event, it is off. Participation start is required.";
|
||||
}
|
||||
}
|
||||
|
||||
// Clean the things we will use, just in case.
|
||||
unspawnEventNpcs();
|
||||
_teams.clear();
|
||||
_connectionLossData.clear();
|
||||
|
||||
// Insert empty lists at _teams.
|
||||
for (int i = 0; i < _teamsNumber; i++)
|
||||
{
|
||||
_teams.put(i + 1, ConcurrentHashMap.newKeySet());
|
||||
}
|
||||
|
||||
int i = 0;
|
||||
while (!_registeredPlayers.isEmpty())
|
||||
{
|
||||
// Get the player with the biggest level
|
||||
int max = 0;
|
||||
PlayerInstance biggestLvlPlayer = null;
|
||||
for (PlayerInstance player : _registeredPlayers)
|
||||
{
|
||||
if (player == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (max < player.getLevel())
|
||||
{
|
||||
max = player.getLevel();
|
||||
biggestLvlPlayer = player;
|
||||
}
|
||||
}
|
||||
|
||||
if (biggestLvlPlayer == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
_registeredPlayers.remove(biggestLvlPlayer);
|
||||
_teams.get(i + 1).add(biggestLvlPlayer);
|
||||
biggestLvlPlayer.setEventStatus();
|
||||
i = (i + 1) % _teamsNumber;
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.warning("Event: " + e.getMessage());
|
||||
return "Cannot start event, an error has occured.";
|
||||
}
|
||||
|
||||
return "The event has been successfully started.";
|
||||
}
|
||||
|
||||
/**
|
||||
* If the event state is OFF, it will not finish. Sets the event state to OFF, unregisters and resets the players, unspawns and clers the event NPCs, clears the teams, registered players, connection loss data, sets the teams number to 0, sets the event name to empty.
|
||||
* @return a string with information if the event has been successfully stopped or not.
|
||||
*/
|
||||
public static String finishEvent()
|
||||
{
|
||||
switch (eventState)
|
||||
{
|
||||
case OFF:
|
||||
{
|
||||
return "Cannot finish event, it is already off.";
|
||||
}
|
||||
case STANDBY:
|
||||
{
|
||||
for (PlayerInstance player : _registeredPlayers)
|
||||
{
|
||||
removeAndResetPlayer(player);
|
||||
}
|
||||
|
||||
unspawnEventNpcs();
|
||||
// _npcs.clear();
|
||||
_registeredPlayers.clear();
|
||||
_teams.clear();
|
||||
_connectionLossData.clear();
|
||||
_teamsNumber = 0;
|
||||
_eventName = "";
|
||||
eventState = EventState.OFF;
|
||||
return "The event has been stopped at STANDBY mode, all players unregistered and all event npcs unspawned.";
|
||||
}
|
||||
case ON:
|
||||
{
|
||||
for (Set<PlayerInstance> teamList : _teams.values())
|
||||
{
|
||||
for (PlayerInstance player : teamList)
|
||||
{
|
||||
removeAndResetPlayer(player);
|
||||
}
|
||||
}
|
||||
|
||||
eventState = EventState.OFF;
|
||||
AntiFeedManager.getInstance().clear(AntiFeedManager.TVT_ID);
|
||||
unspawnEventNpcs(); // Just in case
|
||||
// _npcs.clear();
|
||||
_registeredPlayers.clear();
|
||||
_teams.clear();
|
||||
_connectionLossData.clear();
|
||||
_teamsNumber = 0;
|
||||
_eventName = "";
|
||||
_npcId = 0;
|
||||
_eventCreator = "";
|
||||
_eventInfo = "";
|
||||
return "The event has been stopped, all players unregistered and all event npcs unspawned.";
|
||||
}
|
||||
}
|
||||
|
||||
return "The event has been successfully finished.";
|
||||
}
|
||||
|
||||
private static Map<PlayerInstance, Integer> sortByValue(Map<PlayerInstance, Integer> unsortMap)
|
||||
{
|
||||
final List<Entry<PlayerInstance, Integer>> list = new LinkedList<>(unsortMap.entrySet());
|
||||
list.sort(Comparator.comparing(Entry::getValue));
|
||||
|
||||
final Map<PlayerInstance, Integer> sortedMap = new LinkedHashMap<>();
|
||||
for (Entry<PlayerInstance, Integer> entry : list)
|
||||
{
|
||||
sortedMap.put(entry.getKey(), entry.getValue());
|
||||
}
|
||||
return sortedMap;
|
||||
}
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.instancemanager.events;
|
||||
|
||||
import org.l2jmobius.gameserver.instancemanager.QuestManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.quest.Event;
|
||||
|
||||
/**
|
||||
* @author Mobius
|
||||
*/
|
||||
public class RabbitsManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
{
|
||||
protected RabbitsManager()
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
protected void startEvent()
|
||||
{
|
||||
final Event event = (Event) QuestManager.getInstance().getQuest("Rabbits");
|
||||
if (event != null)
|
||||
{
|
||||
event.eventStart(null);
|
||||
}
|
||||
}
|
||||
|
||||
public static RabbitsManager getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final RabbitsManager INSTANCE = new RabbitsManager();
|
||||
}
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.instancemanager.events;
|
||||
|
||||
import org.l2jmobius.gameserver.instancemanager.QuestManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.quest.Event;
|
||||
|
||||
/**
|
||||
* @author Mobius
|
||||
*/
|
||||
public class RaceManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
{
|
||||
protected RaceManager()
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
protected void startEvent()
|
||||
{
|
||||
final Event event = (Event) QuestManager.getInstance().getQuest("Race");
|
||||
if (event != null)
|
||||
{
|
||||
event.eventStart(null);
|
||||
}
|
||||
}
|
||||
|
||||
public static RaceManager getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final RaceManager INSTANCE = new RaceManager();
|
||||
}
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.instancemanager.events;
|
||||
|
||||
import org.l2jmobius.gameserver.instancemanager.QuestManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.ScheduleTarget;
|
||||
import org.l2jmobius.gameserver.model.quest.Event;
|
||||
|
||||
/**
|
||||
* @author Mobius
|
||||
*/
|
||||
public class TeamVsTeamManager extends AbstractEventManager<AbstractEvent<?>>
|
||||
{
|
||||
protected TeamVsTeamManager()
|
||||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInitialized()
|
||||
{
|
||||
}
|
||||
|
||||
@ScheduleTarget
|
||||
protected void startEvent()
|
||||
{
|
||||
final Event event = (Event) QuestManager.getInstance().getQuest("TvT");
|
||||
if (event != null)
|
||||
{
|
||||
event.eventStart(null);
|
||||
}
|
||||
}
|
||||
|
||||
public static TeamVsTeamManager getInstance()
|
||||
{
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
|
||||
private static class SingletonHolder
|
||||
{
|
||||
protected static final TeamVsTeamManager INSTANCE = new TeamVsTeamManager();
|
||||
}
|
||||
}
|
||||
@@ -1022,7 +1022,7 @@ public abstract class Creature extends WorldObject implements ISkillsHolder, IDe
|
||||
return;
|
||||
}
|
||||
// Events.
|
||||
else if (getActingPlayer().isOnCustomEvent() && target.isPlayable() && (getActingPlayer().getTeam() == target.getActingPlayer().getTeam()))
|
||||
else if (getActingPlayer().isOnEvent() && target.isPlayable() && (getActingPlayer().getTeam() == target.getActingPlayer().getTeam()))
|
||||
{
|
||||
sendPacket(ActionFailed.STATIC_PACKET);
|
||||
return;
|
||||
@@ -5037,15 +5037,6 @@ public abstract class Creature extends WorldObject implements ISkillsHolder, IDe
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Dummy method overriden in {@link PlayerInstance}
|
||||
* @return {@code true} if player is on event, {@code false} otherwise.
|
||||
*/
|
||||
public boolean isOnEvent()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Dummy method overriden in {@link PlayerInstance}
|
||||
* @return the clan id of current character.
|
||||
|
||||
@@ -307,6 +307,11 @@ public abstract class Playable extends Creature
|
||||
|
||||
public abstract void restoreEffects();
|
||||
|
||||
public boolean isOnEvent()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isPlayable()
|
||||
{
|
||||
|
||||
@@ -1131,4 +1131,10 @@ public abstract class Summon extends Playable
|
||||
{
|
||||
return super.isTargetable() && getTemplate().isTargetable();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isOnEvent()
|
||||
{
|
||||
return (_owner != null) && _owner.isOnEvent();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -128,7 +128,6 @@ import org.l2jmobius.gameserver.instancemanager.QuestManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.SellBuffsManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.SiegeManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.ZoneManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.events.GameEvent;
|
||||
import org.l2jmobius.gameserver.model.AccessLevel;
|
||||
import org.l2jmobius.gameserver.model.ArenaParticipantsHolder;
|
||||
import org.l2jmobius.gameserver.model.BlockList;
|
||||
@@ -181,7 +180,6 @@ import org.l2jmobius.gameserver.model.actor.tasks.player.WarnUserTakeBreakTask;
|
||||
import org.l2jmobius.gameserver.model.actor.tasks.player.WaterTask;
|
||||
import org.l2jmobius.gameserver.model.actor.templates.PlayerTemplate;
|
||||
import org.l2jmobius.gameserver.model.actor.transform.Transform;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.clan.Clan;
|
||||
import org.l2jmobius.gameserver.model.clan.ClanMember;
|
||||
import org.l2jmobius.gameserver.model.clan.ClanPrivilege;
|
||||
@@ -189,7 +187,6 @@ import org.l2jmobius.gameserver.model.clan.ClanWar;
|
||||
import org.l2jmobius.gameserver.model.cubic.CubicInstance;
|
||||
import org.l2jmobius.gameserver.model.effects.EffectFlag;
|
||||
import org.l2jmobius.gameserver.model.effects.EffectType;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.events.EventDispatcher;
|
||||
import org.l2jmobius.gameserver.model.events.EventType;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayableExpChanged;
|
||||
@@ -218,7 +215,6 @@ import org.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.MonsterBookCardHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.MonsterBookRewardHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.MovieHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.PlayerEventHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.PreparedMultisellListHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.RecipeHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.SellBuffHolder;
|
||||
@@ -697,10 +693,6 @@ public class PlayerInstance extends Playable
|
||||
|
||||
private final Map<Integer, ExResponseCommissionInfo> _lastCommissionInfos = new ConcurrentHashMap<>();
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
private final Map<Class<? extends AbstractEvent>, AbstractEvent<?>> _events = new ConcurrentHashMap<>();
|
||||
private boolean _isOnCustomEvent = false;
|
||||
|
||||
// protects a char from aggro mobs when getting up from fake death
|
||||
private long _recentFakeDeathEndTime = 0;
|
||||
|
||||
@@ -731,7 +723,9 @@ public class PlayerInstance extends Playable
|
||||
private BroochJewel _activeShappireJewel = null;
|
||||
|
||||
/** Event parameters */
|
||||
private PlayerEventHolder eventStatus = null;
|
||||
private boolean _isRegisteredOnEvent = false;
|
||||
private boolean _isOnSoloEvent = false;
|
||||
private boolean _isOnEvent = false;
|
||||
|
||||
private byte _handysBlockCheckerEventArena = -1;
|
||||
|
||||
@@ -858,7 +852,7 @@ public class PlayerInstance extends Playable
|
||||
|
||||
// Shared dualclass skills.
|
||||
private static final String KNOWN_DUAL_SKILLS_VAR = "KNOWN_DUAL_SKILLS";
|
||||
private static final int[] DUAL_CLASS_SKILLS = new int[]
|
||||
private static final int[] DUAL_CLASS_SKILLS =
|
||||
{
|
||||
19222, // Dignity of the Exalted
|
||||
19223, // Belief of the Exalted
|
||||
@@ -2927,11 +2921,7 @@ public class PlayerInstance extends Playable
|
||||
*/
|
||||
public void standUp()
|
||||
{
|
||||
if (GameEvent.isParticipant(this) && eventStatus.isSitForced())
|
||||
{
|
||||
sendMessage("A dark force beyond your mortal understanding makes your knees to shake when you try to stand up...");
|
||||
}
|
||||
else if (_waitTypeSitting && !isInStoreMode() && !isAlikeDead())
|
||||
if (_waitTypeSitting && !isInStoreMode() && !isAlikeDead())
|
||||
{
|
||||
if (getEffectList().isAffected(EffectFlag.RELAXING))
|
||||
{
|
||||
@@ -4867,10 +4857,6 @@ public class PlayerInstance extends Playable
|
||||
if (pk != null)
|
||||
{
|
||||
EventDispatcher.getInstance().notifyEventAsync(new OnPlayerPvPKill(pk, this), this);
|
||||
if (GameEvent.isParticipant(pk))
|
||||
{
|
||||
pk.getEventStatus().addKill(this);
|
||||
}
|
||||
|
||||
// pvp/pk item rewards
|
||||
if (!(Config.DISABLE_REWARDS_IN_INSTANCES && (getInstanceId() != 0)) && //
|
||||
@@ -5034,7 +5020,7 @@ public class PlayerInstance extends Playable
|
||||
|
||||
private void onDieDropItem(Creature killer)
|
||||
{
|
||||
if (GameEvent.isParticipant(this) || (killer == null))
|
||||
if (isOnEvent() || (killer == null))
|
||||
{
|
||||
return;
|
||||
}
|
||||
@@ -5360,7 +5346,7 @@ public class PlayerInstance extends Playable
|
||||
|
||||
// Calculate the Experience loss
|
||||
long lostExp = 0;
|
||||
if (!GameEvent.isParticipant(this))
|
||||
if (!isOnEvent())
|
||||
{
|
||||
if (lvl < ExperienceData.getInstance().getMaxLevel())
|
||||
{
|
||||
@@ -8120,7 +8106,7 @@ public class PlayerInstance extends Playable
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isBlockedFromExit())
|
||||
if (isRegisteredOnEvent())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
@@ -8181,22 +8167,13 @@ public class PlayerInstance extends Playable
|
||||
// Check if the attacker is in olympia and olympia start
|
||||
if (attacker.isPlayer() && attacker.getActingPlayer().isInOlympiadMode())
|
||||
{
|
||||
if (_inOlympiadMode && _olympiadStart && (((PlayerInstance) attacker).getOlympiadGameId() == getOlympiadGameId()))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return _inOlympiadMode && _olympiadStart && (((PlayerInstance) attacker).getOlympiadGameId() == getOlympiadGameId());
|
||||
}
|
||||
|
||||
if (_isOnCustomEvent && (getTeam() == attacker.getTeam()))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// CoC needs this check?
|
||||
// Check if the attacker is in an event
|
||||
if (isOnEvent())
|
||||
{
|
||||
return true;
|
||||
return isOnSoloEvent() || (getTeam() != attacker.getTeam());
|
||||
}
|
||||
|
||||
// Check if the attacker is a Playable
|
||||
@@ -9371,12 +9348,7 @@ public class PlayerInstance extends Playable
|
||||
_noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_ALREADY_ENGAGED_IN_A_DUEL;
|
||||
return false;
|
||||
}
|
||||
if (_inOlympiadMode || isOnEvent(CeremonyOfChaosEvent.class))
|
||||
{
|
||||
_noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_PARTICIPATING_IN_THE_OLYMPIAD_OR_THE_CEREMONY_OF_CHAOS;
|
||||
return false;
|
||||
}
|
||||
if (isOnEvent()) // custom event message
|
||||
if (_inOlympiadMode || isRegisteredOnEvent())
|
||||
{
|
||||
_noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_ENGAGED_IN_BATTLE;
|
||||
return false;
|
||||
@@ -11160,12 +11132,6 @@ public class PlayerInstance extends Playable
|
||||
EventDispatcher.getInstance().notifyEventAsync(new OnPlayerMentorStatus(this, false), this);
|
||||
}
|
||||
|
||||
// we store all data from players who are disconnected while in an event in order to restore it in the next login
|
||||
if (GameEvent.isParticipant(this))
|
||||
{
|
||||
GameEvent.savePlayerEventStatus(this);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
notifyFriends(FriendStatus.MODE_OFFLINE);
|
||||
@@ -13032,16 +12998,6 @@ public class PlayerInstance extends Playable
|
||||
_adminConfirmCmd = adminConfirmCmd;
|
||||
}
|
||||
|
||||
public void setBlockCheckerArena(byte arena)
|
||||
{
|
||||
_handysBlockCheckerEventArena = arena;
|
||||
}
|
||||
|
||||
public int getBlockCheckerArena()
|
||||
{
|
||||
return _handysBlockCheckerEventArena;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load PlayerInstance Recommendations data.
|
||||
*/
|
||||
@@ -13140,21 +13096,6 @@ public class PlayerInstance extends Playable
|
||||
return _contactList;
|
||||
}
|
||||
|
||||
public void setEventStatus()
|
||||
{
|
||||
eventStatus = new PlayerEventHolder(this);
|
||||
}
|
||||
|
||||
public void setEventStatus(PlayerEventHolder pes)
|
||||
{
|
||||
eventStatus = pes;
|
||||
}
|
||||
|
||||
public PlayerEventHolder getEventStatus()
|
||||
{
|
||||
return eventStatus;
|
||||
}
|
||||
|
||||
public long getNotMoveUntil()
|
||||
{
|
||||
return _notMoveUntil;
|
||||
@@ -13214,13 +13155,6 @@ public class PlayerInstance extends Playable
|
||||
@Override
|
||||
public boolean canRevive()
|
||||
{
|
||||
for (AbstractEvent<?> listener : _events.values())
|
||||
{
|
||||
if (listener.isOnEvent(this) && !listener.canRevive(this))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return _canRevive;
|
||||
}
|
||||
|
||||
@@ -13234,66 +13168,50 @@ public class PlayerInstance extends Playable
|
||||
_canRevive = value;
|
||||
}
|
||||
|
||||
public boolean isOnCustomEvent()
|
||||
public boolean isRegisteredOnEvent()
|
||||
{
|
||||
return _isOnCustomEvent;
|
||||
return _isRegisteredOnEvent || _isOnEvent;
|
||||
}
|
||||
|
||||
public void setOnCustomEvent(boolean value)
|
||||
public void setRegisteredOnEvent(boolean value)
|
||||
{
|
||||
_isOnCustomEvent = value;
|
||||
_isRegisteredOnEvent = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {@code true} if player is on event, {@code false} otherwise.
|
||||
*/
|
||||
@Override
|
||||
public boolean isOnEvent()
|
||||
{
|
||||
if (_isOnCustomEvent)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
for (AbstractEvent<?> listener : _events.values())
|
||||
{
|
||||
if (listener.isOnEvent(this))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return super.isOnEvent();
|
||||
return _isOnEvent;
|
||||
}
|
||||
|
||||
public boolean isBlockedFromExit()
|
||||
public void setOnEvent(boolean value)
|
||||
{
|
||||
if (_isOnCustomEvent)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
for (AbstractEvent<?> listener : _events.values())
|
||||
{
|
||||
if (listener.isOnEvent(this) && listener.isBlockingExit(this))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
_isOnEvent = value;
|
||||
}
|
||||
|
||||
public boolean isOnSoloEvent()
|
||||
{
|
||||
return _isOnSoloEvent;
|
||||
}
|
||||
|
||||
public void setOnSoloEvent(boolean value)
|
||||
{
|
||||
_isOnSoloEvent = value;
|
||||
}
|
||||
|
||||
public boolean isBlockedFromDeathPenalty()
|
||||
{
|
||||
if (_isOnCustomEvent)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
for (AbstractEvent<?> listener : _events.values())
|
||||
{
|
||||
if (listener.isOnEvent(this) && listener.isBlockingDeathPenalty(this))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return isAffected(EffectFlag.PROTECT_DEATH_PENALTY);
|
||||
return _isOnEvent || isAffected(EffectFlag.PROTECT_DEATH_PENALTY);
|
||||
}
|
||||
|
||||
public void setBlockCheckerArena(byte arena)
|
||||
{
|
||||
_handysBlockCheckerEventArena = arena;
|
||||
}
|
||||
|
||||
public int getBlockCheckerArena()
|
||||
{
|
||||
return _handysBlockCheckerEventArena;
|
||||
}
|
||||
|
||||
public void setOriginalCpHpMp(double cp, double hp, double mp)
|
||||
@@ -13844,63 +13762,6 @@ public class PlayerInstance extends Playable
|
||||
sendPacket(new ExUserInfoInvenWeight(this));
|
||||
}
|
||||
|
||||
/**
|
||||
* @param event
|
||||
* @return {@code true} if event is successfuly registered, {@code false} in case events map is not initialized yet or event is not registered
|
||||
*/
|
||||
public boolean registerOnEvent(AbstractEvent<?> event)
|
||||
{
|
||||
return _events.putIfAbsent(event.getClass(), event) == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param event
|
||||
* @return {@code true} if event is successfuly removed, {@code false} in case events map is not initialized yet or event is not registered
|
||||
*/
|
||||
public boolean removeFromEvent(AbstractEvent<?> event)
|
||||
{
|
||||
return _events.remove(event.getClass()) != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param <T>
|
||||
* @param clazz
|
||||
* @return the event instance or null in case events map is not initialized yet or event is not registered
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T extends AbstractEvent<?>> T getEvent(Class<T> clazz)
|
||||
{
|
||||
for (AbstractEvent<?> event : _events.values())
|
||||
{
|
||||
if (clazz.isAssignableFrom(event.getClass()))
|
||||
{
|
||||
return (T) event;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the first event that player participates on or null if he doesn't
|
||||
*/
|
||||
public AbstractEvent<?> getEvent()
|
||||
{
|
||||
for (AbstractEvent<?> event : _events.values())
|
||||
{
|
||||
return event;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param clazz
|
||||
* @return {@code true} if player is registered on specified event, {@code false} in case events map is not initialized yet or event is not registered
|
||||
*/
|
||||
public boolean isOnEvent(Class<? extends AbstractEvent<?>> clazz)
|
||||
{
|
||||
return _events.containsKey(clazz);
|
||||
}
|
||||
|
||||
public Fishing getFishing()
|
||||
{
|
||||
return _fishing;
|
||||
|
||||
@@ -1,702 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.ceremonyofchaos;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.OptionalInt;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.l2jmobius.Config;
|
||||
import org.l2jmobius.commons.util.Chronos;
|
||||
import org.l2jmobius.commons.util.Rnd;
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosResult;
|
||||
import org.l2jmobius.gameserver.enums.QuestSound;
|
||||
import org.l2jmobius.gameserver.instancemanager.CeremonyOfChaosManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.GlobalVariablesManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.InstanceManager;
|
||||
import org.l2jmobius.gameserver.model.Location;
|
||||
import org.l2jmobius.gameserver.model.Party;
|
||||
import org.l2jmobius.gameserver.model.Party.MessageType;
|
||||
import org.l2jmobius.gameserver.model.StatSet;
|
||||
import org.l2jmobius.gameserver.model.actor.Npc;
|
||||
import org.l2jmobius.gameserver.model.actor.Summon;
|
||||
import org.l2jmobius.gameserver.model.actor.appearance.PlayerAppearance;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.MonsterInstance;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEvent;
|
||||
import org.l2jmobius.gameserver.model.events.AbstractScript;
|
||||
import org.l2jmobius.gameserver.model.events.EventDispatcher;
|
||||
import org.l2jmobius.gameserver.model.events.EventType;
|
||||
import org.l2jmobius.gameserver.model.events.ListenerRegisterType;
|
||||
import org.l2jmobius.gameserver.model.events.annotations.RegisterEvent;
|
||||
import org.l2jmobius.gameserver.model.events.annotations.RegisterType;
|
||||
import org.l2jmobius.gameserver.model.events.impl.ceremonyofchaos.OnCeremonyOfChaosMatchResult;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.OnCreatureDeath;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayerLogout;
|
||||
import org.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
import org.l2jmobius.gameserver.model.holders.SkillHolder;
|
||||
import org.l2jmobius.gameserver.model.instancezone.Instance;
|
||||
import org.l2jmobius.gameserver.model.instancezone.InstanceTemplate;
|
||||
import org.l2jmobius.gameserver.model.quest.QuestState;
|
||||
import org.l2jmobius.gameserver.model.skills.Skill;
|
||||
import org.l2jmobius.gameserver.model.variables.PlayerVariables;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.DeleteObject;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ExUserInfoAbnormalVisualEffect;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.NpcHtmlMessage;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.SkillCoolTime;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.SystemMessage;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.appearance.ExCuriousHouseMemberUpdate;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseEnter;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseLeave;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseMemberList;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseObserveMode;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseRemainTime;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseResult;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class CeremonyOfChaosEvent extends AbstractEvent<CeremonyOfChaosMember>
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(CeremonyOfChaosEvent.class.getName());
|
||||
|
||||
private final int _id;
|
||||
private final Instance _instance;
|
||||
private final Set<MonsterInstance> _monsters = ConcurrentHashMap.newKeySet();
|
||||
private long _battleStartTime = 0;
|
||||
|
||||
public CeremonyOfChaosEvent(int id, InstanceTemplate template)
|
||||
{
|
||||
_id = id;
|
||||
_instance = InstanceManager.getInstance().createInstance(template, null);
|
||||
if (_instance.getEnterLocations().size() < CeremonyOfChaosManager.getInstance().getMaxPlayersInArena())
|
||||
{
|
||||
LOGGER.warning("There are more member slots: " + _instance.getEnterLocations().size() + " then instance entrance positions: " + CeremonyOfChaosManager.getInstance().getMaxPlayersInArena() + "!");
|
||||
}
|
||||
}
|
||||
|
||||
public int getId()
|
||||
{
|
||||
return _id;
|
||||
}
|
||||
|
||||
public int getInstanceId()
|
||||
{
|
||||
return _instance.getId();
|
||||
}
|
||||
|
||||
public Instance getInstance()
|
||||
{
|
||||
return _instance;
|
||||
}
|
||||
|
||||
public Set<MonsterInstance> getMonsters()
|
||||
{
|
||||
return _monsters;
|
||||
}
|
||||
|
||||
public void preparePlayers()
|
||||
{
|
||||
final Map<Integer, CeremonyOfChaosMember> members = getMembers();
|
||||
final ExCuriousHouseMemberList membersList = new ExCuriousHouseMemberList(_id, CeremonyOfChaosManager.getInstance().getMaxPlayersInArena(), members.values());
|
||||
final NpcHtmlMessage msg = new NpcHtmlMessage(0);
|
||||
int index = 0;
|
||||
for (CeremonyOfChaosMember member : members.values())
|
||||
{
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if (player.inObserverMode())
|
||||
{
|
||||
player.leaveObserverMode();
|
||||
}
|
||||
|
||||
if (player.isInDuel())
|
||||
{
|
||||
player.setInDuel(0);
|
||||
}
|
||||
|
||||
// Remember player's last location
|
||||
player.setLastLocation();
|
||||
|
||||
// Hide player information
|
||||
final PlayerAppearance app = player.getAppearance();
|
||||
app.setVisibleName("Challenger" + member.getPosition());
|
||||
app.setVisibleTitle("");
|
||||
app.setVisibleClanData(0, 0, 0, 0, 0);
|
||||
|
||||
// Register the event instance
|
||||
player.registerOnEvent(this);
|
||||
|
||||
// Load the html
|
||||
msg.setFile(player, "data/html/CeremonyOfChaos/started.htm");
|
||||
|
||||
// Remove buffs
|
||||
player.stopAllEffectsExceptThoseThatLastThroughDeath();
|
||||
player.getEffectList().stopEffects(info -> info.getSkill().isBlockedInOlympiad(), true, true);
|
||||
|
||||
// Player shouldn't be able to move and is hidden
|
||||
player.setImmobilized(true);
|
||||
player.setInvisible(true);
|
||||
|
||||
// Same goes for summon
|
||||
player.getServitors().values().forEach(s ->
|
||||
{
|
||||
s.stopAllEffectsExceptThoseThatLastThroughDeath();
|
||||
s.setInvisible(true);
|
||||
s.setImmobilized(true);
|
||||
});
|
||||
|
||||
if (player.isFlyingMounted())
|
||||
{
|
||||
player.untransform();
|
||||
}
|
||||
|
||||
// If player is dead, revive it
|
||||
if (player.isDead())
|
||||
{
|
||||
player.doRevive();
|
||||
}
|
||||
|
||||
// If player is sitting, stand up
|
||||
if (player.isSitting())
|
||||
{
|
||||
player.standUp();
|
||||
}
|
||||
|
||||
// If player in party, leave it
|
||||
final Party party = player.getParty();
|
||||
if (party != null)
|
||||
{
|
||||
party.removePartyMember(player, MessageType.EXPELLED);
|
||||
}
|
||||
|
||||
// Cancel any started action
|
||||
player.abortAttack();
|
||||
player.abortCast();
|
||||
player.stopMove(null);
|
||||
player.setTarget(null);
|
||||
|
||||
// Unsummon pet
|
||||
final Summon pet = player.getPet();
|
||||
if (pet != null)
|
||||
{
|
||||
pet.unSummon(player);
|
||||
}
|
||||
|
||||
// Unsummon agathion
|
||||
if (player.getAgathionId() > 0)
|
||||
{
|
||||
player.setAgathionId(0);
|
||||
}
|
||||
|
||||
// The character’s HP, MP, and CP are fully recovered.
|
||||
player.setCurrentHp(player.getMaxHp());
|
||||
player.setCurrentMp(player.getMaxMp());
|
||||
player.setCurrentCp(player.getMaxCp());
|
||||
|
||||
// Skill reuse timers for all skills that have less than 15 minutes of cooldown time are reset.
|
||||
for (Skill skill : player.getAllSkills())
|
||||
{
|
||||
if (skill.getReuseDelay() <= 900000)
|
||||
{
|
||||
player.enableSkill(skill);
|
||||
}
|
||||
}
|
||||
|
||||
player.sendSkillList();
|
||||
player.sendPacket(new SkillCoolTime(player));
|
||||
|
||||
// Apply the Energy of Chaos skill
|
||||
for (SkillHolder holder : CeremonyOfChaosManager.getInstance().getVariables().getList(CeremonyOfChaosManager.INITIAL_BUFF_KEY, SkillHolder.class))
|
||||
{
|
||||
holder.getSkill().activateSkill(player, player);
|
||||
}
|
||||
|
||||
// Send Enter packet
|
||||
player.sendPacket(ExCuriousHouseEnter.STATIC_PACKET);
|
||||
|
||||
// Send all members
|
||||
player.sendPacket(membersList);
|
||||
|
||||
// Send the entrance html
|
||||
player.sendPacket(msg);
|
||||
|
||||
// Send support items to player
|
||||
for (ItemHolder holder : CeremonyOfChaosManager.getInstance().getRewards(CeremonyOfChaosManager.INITIAL_ITEMS_KEY).calculateDrops())
|
||||
{
|
||||
player.addItem("CoC", holder, null, true);
|
||||
}
|
||||
|
||||
// Teleport player to the arena
|
||||
player.teleToLocation(_instance.getEnterLocations().get(index++), 0, _instance);
|
||||
}
|
||||
|
||||
final StatSet params = new StatSet();
|
||||
params.set("time", 60);
|
||||
getTimers().addTimer("match_start_countdown", params, 100, null, null);
|
||||
getTimers().addTimer("teleport_message1", 10000, null, null);
|
||||
getTimers().addTimer("teleport_message2", 14000, null, null);
|
||||
getTimers().addTimer("teleport_message3", 18000, null, null);
|
||||
}
|
||||
|
||||
public void startFight()
|
||||
{
|
||||
for (CeremonyOfChaosMember member : getMembers().values())
|
||||
{
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if (player != null)
|
||||
{
|
||||
player.sendPacket(SystemMessageId.THE_MATCH_HAS_STARTED_FIGHT);
|
||||
player.setImmobilized(false);
|
||||
player.setInvisible(false);
|
||||
player.broadcastInfo();
|
||||
player.sendPacket(new ExUserInfoAbnormalVisualEffect(player));
|
||||
player.getServitors().values().forEach(s ->
|
||||
{
|
||||
s.setInvisible(false);
|
||||
s.setImmobilized(false);
|
||||
s.broadcastInfo();
|
||||
});
|
||||
}
|
||||
}
|
||||
_battleStartTime = Chronos.currentTimeMillis();
|
||||
getTimers().addRepeatingTimer("update", 1000, null, null);
|
||||
}
|
||||
|
||||
public void stopFight()
|
||||
{
|
||||
final Map<Integer, CeremonyOfChaosMember> members = getMembers();
|
||||
for (CeremonyOfChaosMember member : members.values())
|
||||
{
|
||||
if (member.getLifeTime() == 0)
|
||||
{
|
||||
updateLifeTime(member);
|
||||
}
|
||||
}
|
||||
validateWinner();
|
||||
|
||||
final List<CeremonyOfChaosMember> winners = getWinners();
|
||||
final List<CeremonyOfChaosMember> memberList = new ArrayList<>(members.size());
|
||||
SystemMessage msg = null;
|
||||
if (winners.isEmpty() || (winners.size() > 1))
|
||||
{
|
||||
msg = new SystemMessage(SystemMessageId.THERE_IS_NO_VICTOR_THE_MATCH_ENDS_IN_A_TIE);
|
||||
}
|
||||
else
|
||||
{
|
||||
final PlayerInstance winner = winners.get(0).getPlayer();
|
||||
if (winner != null)
|
||||
{
|
||||
msg = new SystemMessage(SystemMessageId.CONGRATULATIONS_C1_YOU_WIN_THE_MATCH);
|
||||
msg.addString(winner.getName());
|
||||
|
||||
// Rewards according to https://l2wiki.com/Ceremony_of_Chaos
|
||||
final int marksRewarded = Rnd.get(2, 4);
|
||||
winner.addItem("CoC-Winner", 34900, marksRewarded, winner, true); // Mysterious Marks
|
||||
|
||||
// Possible additional rewards
|
||||
|
||||
// Improved Life Stone
|
||||
if (Rnd.get(10) < 3) // Chance to get reward (30%)
|
||||
{
|
||||
switch (Rnd.get(4))
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 18570, 1, winner, true); // Improved Life Stone (R95-grade)
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 18571, 1, winner, true); // Improved Life Stone (R95-grade)
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 18575, 1, winner, true); // Improved Life Stone (R99-grade)
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 18576, 1, winner, true); // Improved Life Stone (R99-grade)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Soul Crystal Fragment
|
||||
else if (Rnd.get(10) < 3) // Chance to get reward (30%)
|
||||
{
|
||||
switch (Rnd.get(6))
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 19467, 1, winner, true); // Yellow Soul Crystal Fragment (R99-Grade)
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 19468, 1, winner, true); // Teal Soul Crystal Fragment (R99-Grade)
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 19469, 1, winner, true); // Purple Soul Crystal Fragment (R99-Grade)
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 19511, 1, winner, true); // Yellow Soul Crystal Fragment (R95-Grade)
|
||||
break;
|
||||
}
|
||||
case 4:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 19512, 1, winner, true); // Teal Soul Crystal Fragment (R95-Grade)
|
||||
break;
|
||||
}
|
||||
case 5:
|
||||
{
|
||||
winner.addItem("CoC-Winner", 19513, 1, winner, true); // Purple Soul Crystal Fragment (R95-Grade)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Mysterious Belt
|
||||
else if (Rnd.get(10) < 1) // Chance to get reward (10%)
|
||||
{
|
||||
winner.addItem("CoC-Winner", 35565, 1, winner, true); // Mysterious Belt
|
||||
}
|
||||
|
||||
// Save monthly progress.
|
||||
final int totalMarks = winner.getVariables().getInt(PlayerVariables.CEREMONY_OF_CHAOS_MARKS, 0) + marksRewarded;
|
||||
winner.getVariables().set(PlayerVariables.CEREMONY_OF_CHAOS_MARKS, totalMarks);
|
||||
if (totalMarks > GlobalVariablesManager.getInstance().getInt(GlobalVariablesManager.COC_TOP_MARKS, 0))
|
||||
{
|
||||
GlobalVariablesManager.getInstance().set(GlobalVariablesManager.COC_TOP_MARKS, totalMarks);
|
||||
GlobalVariablesManager.getInstance().set(GlobalVariablesManager.COC_TOP_MEMBER, winner.getObjectId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (CeremonyOfChaosMember member : members.values())
|
||||
{
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if (player != null)
|
||||
{
|
||||
// Send winner message
|
||||
if (msg != null)
|
||||
{
|
||||
player.sendPacket(msg);
|
||||
}
|
||||
|
||||
// Send result
|
||||
player.sendPacket(new ExCuriousHouseResult(member.getResultType(), this));
|
||||
memberList.add(member);
|
||||
}
|
||||
}
|
||||
getTimers().cancelTimer("update", null, null);
|
||||
final StatSet params = new StatSet();
|
||||
params.set("time", 30);
|
||||
getTimers().addTimer("match_end_countdown", params, 30 * 1000, null, null);
|
||||
EventDispatcher.getInstance().notifyEvent(new OnCeremonyOfChaosMatchResult(winners, memberList));
|
||||
|
||||
// XXX: ML2 Rewards ForGlory, ForHonor and ForVictory quests
|
||||
for (CeremonyOfChaosMember member : getMembers().values())
|
||||
{
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if (player == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
final QuestState qs = player.getQuestState("Q10813_ForGlory");
|
||||
final QuestState qs1 = player.getQuestState("Q10819_ForHonor");
|
||||
if ((qs != null) && !qs.isCompleted() && qs.isCond(1))
|
||||
{
|
||||
AbstractScript.giveItems(player, Config.EXALTED_FOR_GLORY_ITEM_MAX.getId(), 1);
|
||||
AbstractScript.playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
|
||||
if (AbstractScript.getQuestItemsCount(player, Config.EXALTED_FOR_GLORY_ITEM_MAX.getId()) >= Config.EXALTED_FOR_GLORY_ITEM_MAX.getCount())
|
||||
{
|
||||
qs.setCond(2, true);
|
||||
}
|
||||
}
|
||||
else if ((qs1 != null) && !qs1.isCompleted() && qs1.isCond(1))
|
||||
{
|
||||
AbstractScript.giveItems(player, Config.EXALTED_FOR_HONOR_ITEM_MAX.getId(), 1);
|
||||
AbstractScript.playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
|
||||
if (AbstractScript.getQuestItemsCount(player, Config.EXALTED_FOR_HONOR_ITEM_MAX.getId()) >= Config.EXALTED_FOR_HONOR_ITEM_MAX.getCount())
|
||||
{
|
||||
qs1.setCond(2, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void teleportPlayersOut()
|
||||
{
|
||||
for (CeremonyOfChaosMember member : getMembers().values())
|
||||
{
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if (player != null)
|
||||
{
|
||||
// Leaves observer mode
|
||||
if (player.inObserverMode())
|
||||
{
|
||||
player.setObserving(false);
|
||||
}
|
||||
|
||||
// Revive the player
|
||||
player.doRevive();
|
||||
|
||||
// Remove Energy of Chaos
|
||||
for (SkillHolder holder : CeremonyOfChaosManager.getInstance().getVariables().getList(CeremonyOfChaosManager.INITIAL_BUFF_KEY, SkillHolder.class))
|
||||
{
|
||||
player.stopSkillEffects(holder.getSkill());
|
||||
}
|
||||
|
||||
// Apply buffs on players
|
||||
for (SkillHolder holder : CeremonyOfChaosManager.getInstance().getVariables().getList(CeremonyOfChaosManager.END_BUFFS_KEYH, SkillHolder.class))
|
||||
{
|
||||
holder.getSkill().activateSkill(player, player);
|
||||
}
|
||||
|
||||
// Remove quit button
|
||||
player.sendPacket(ExCuriousHouseLeave.STATIC_PACKET);
|
||||
|
||||
// Remove spectator mode
|
||||
player.setObserving(false);
|
||||
player.sendPacket(ExCuriousHouseObserveMode.STATIC_DISABLED);
|
||||
|
||||
// Teleport player back
|
||||
final Location lastLocation = player.getLastLocation();
|
||||
player.teleToLocation(lastLocation != null ? lastLocation : new Location(82201, 147587, -3473), null);
|
||||
|
||||
// Restore player information
|
||||
final PlayerAppearance app = player.getAppearance();
|
||||
app.setVisibleName(null);
|
||||
app.setVisibleTitle(null);
|
||||
app.setVisibleClanData(-1, -1, -1, -1, -1);
|
||||
|
||||
// Remove player from event
|
||||
player.removeFromEvent(this);
|
||||
}
|
||||
}
|
||||
|
||||
clearMembers();
|
||||
_instance.destroy();
|
||||
}
|
||||
|
||||
private void updateLifeTime(CeremonyOfChaosMember member)
|
||||
{
|
||||
member.setLifeTime(((int) (Chronos.currentTimeMillis() - _battleStartTime) / 1000));
|
||||
}
|
||||
|
||||
public List<CeremonyOfChaosMember> getWinners()
|
||||
{
|
||||
final List<CeremonyOfChaosMember> winners = new ArrayList<>();
|
||||
final Map<Integer, CeremonyOfChaosMember> members = getMembers();
|
||||
|
||||
//@formatter:off
|
||||
final OptionalInt winnerLifeTime = members.values().stream()
|
||||
.mapToInt(CeremonyOfChaosMember::getLifeTime)
|
||||
.max();
|
||||
|
||||
if(winnerLifeTime.isPresent())
|
||||
{
|
||||
members.values().stream()
|
||||
.sorted(Comparator.comparingLong(CeremonyOfChaosMember::getLifeTime)
|
||||
.reversed()
|
||||
.thenComparingInt(CeremonyOfChaosMember::getScore)
|
||||
.reversed())
|
||||
.filter(member -> member.getLifeTime() == winnerLifeTime.getAsInt())
|
||||
.collect(Collectors.toCollection(() -> winners));
|
||||
}
|
||||
|
||||
//@formatter:on
|
||||
|
||||
return winners;
|
||||
}
|
||||
|
||||
private void validateWinner()
|
||||
{
|
||||
final List<CeremonyOfChaosMember> winners = getWinners();
|
||||
winners.forEach(winner -> winner.setResultType(winners.size() > 1 ? CeremonyOfChaosResult.TIE : CeremonyOfChaosResult.WIN));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onTimerEvent(String event, StatSet params, Npc npc, PlayerInstance player)
|
||||
{
|
||||
switch (event)
|
||||
{
|
||||
case "update":
|
||||
{
|
||||
final Map<Integer, CeremonyOfChaosMember> members = getMembers();
|
||||
|
||||
final int time = (int) CeremonyOfChaosManager.getInstance().getScheduler("stopFight").getRemainingTime(TimeUnit.SECONDS);
|
||||
broadcastPacket(new ExCuriousHouseRemainTime(time));
|
||||
members.values().forEach(p -> broadcastPacket(new ExCuriousHouseMemberUpdate(p)));
|
||||
|
||||
// Validate winner
|
||||
int count = 0;
|
||||
for (CeremonyOfChaosMember member : members.values())
|
||||
{
|
||||
if (!member.isDefeated())
|
||||
{
|
||||
count++;
|
||||
}
|
||||
}
|
||||
if (count <= 1)
|
||||
{
|
||||
stopFight();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "teleport_message1":
|
||||
{
|
||||
broadcastPacket(new SystemMessage(SystemMessageId.PROVE_YOUR_ABILITIES));
|
||||
break;
|
||||
}
|
||||
case "teleport_message2":
|
||||
{
|
||||
broadcastPacket(new SystemMessage(SystemMessageId.THERE_ARE_NO_ALLIES_HERE_EVERYONE_IS_AN_ENEMY));
|
||||
break;
|
||||
}
|
||||
case "teleport_message3":
|
||||
{
|
||||
broadcastPacket(new SystemMessage(SystemMessageId.IT_WILL_BE_A_LONELY_BATTLE_BUT_I_WISH_YOU_VICTORY));
|
||||
break;
|
||||
}
|
||||
case "match_start_countdown":
|
||||
{
|
||||
final int time = params.getInt("time", 0);
|
||||
final SystemMessage countdown = new SystemMessage(SystemMessageId.THE_MATCH_WILL_START_IN_S1_SECOND_S);
|
||||
countdown.addByte(time);
|
||||
broadcastPacket(countdown);
|
||||
|
||||
// Reschedule
|
||||
if (time == 60)
|
||||
{
|
||||
params.set("time", 30);
|
||||
getTimers().addTimer(event, params, 30 * 1000, null, null);
|
||||
}
|
||||
else if ((time == 30) || (time == 20))
|
||||
{
|
||||
params.set("time", time - 10);
|
||||
getTimers().addTimer(event, params, 10 * 1000, null, null);
|
||||
}
|
||||
else if (time == 10)
|
||||
{
|
||||
params.set("time", 5);
|
||||
getTimers().addTimer(event, params, 5 * 1000, null, null);
|
||||
}
|
||||
else if ((time > 1) && (time <= 5))
|
||||
{
|
||||
params.set("time", time - 1);
|
||||
getTimers().addTimer(event, params, 1000, null, null);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "match_end_countdown":
|
||||
{
|
||||
final int time = params.getInt("time", 0);
|
||||
final SystemMessage countdown = new SystemMessage(SystemMessageId.IN_S1_SECOND_S_YOU_WILL_BE_MOVED_TO_WHERE_YOU_WERE_BEFORE_PARTICIPATING_IN_THE_CEREMONY_OF_CHAOS);
|
||||
countdown.addByte(time);
|
||||
broadcastPacket(countdown);
|
||||
|
||||
// Reschedule
|
||||
if ((time == 30) || (time == 20))
|
||||
{
|
||||
params.set("time", time - 10);
|
||||
getTimers().addTimer(event, params, 10 * 1000, null, null);
|
||||
}
|
||||
else if ((time > 0) && (time <= 10))
|
||||
{
|
||||
params.set("time", time - 1);
|
||||
getTimers().addTimer(event, params, 1000, null, null);
|
||||
}
|
||||
else if (time == 0)
|
||||
{
|
||||
teleportPlayersOut();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@RegisterEvent(EventType.ON_PLAYER_LOGOUT)
|
||||
@RegisterType(ListenerRegisterType.GLOBAL_PLAYERS)
|
||||
private void OnPlayerLogout(OnPlayerLogout event)
|
||||
{
|
||||
final PlayerInstance player = event.getPlayer();
|
||||
if (player != null)
|
||||
{
|
||||
final Map<Integer, CeremonyOfChaosMember> members = getMembers();
|
||||
final int playerObjectId = player.getObjectId();
|
||||
if (members.containsKey(playerObjectId))
|
||||
{
|
||||
removeMember(playerObjectId);
|
||||
if (members.size() <= 1)
|
||||
{
|
||||
stopFight();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@RegisterEvent(EventType.ON_CREATURE_DEATH)
|
||||
@RegisterType(ListenerRegisterType.GLOBAL_PLAYERS)
|
||||
public void onPlayerDeath(OnCreatureDeath event)
|
||||
{
|
||||
if (event.getAttacker().isPlayer() && event.getTarget().isPlayer())
|
||||
{
|
||||
final PlayerInstance attackerPlayer = event.getAttacker().getActingPlayer();
|
||||
final PlayerInstance targetPlayer = event.getTarget().getActingPlayer();
|
||||
final Map<Integer, CeremonyOfChaosMember> members = getMembers();
|
||||
final CeremonyOfChaosMember attackerMember = members.get(attackerPlayer.getObjectId());
|
||||
final CeremonyOfChaosMember targetMember = members.get(targetPlayer.getObjectId());
|
||||
final DeleteObject deleteObject = new DeleteObject(targetPlayer);
|
||||
if ((attackerMember != null) && (targetMember != null))
|
||||
{
|
||||
attackerMember.incrementScore();
|
||||
updateLifeTime(targetMember);
|
||||
|
||||
// Mark player as defeated
|
||||
targetMember.setDefeated(true);
|
||||
|
||||
// Delete target player
|
||||
for (CeremonyOfChaosMember member : members.values())
|
||||
{
|
||||
if (member.getObjectId() != targetPlayer.getObjectId())
|
||||
{
|
||||
deleteObject.sendTo(member.getPlayer());
|
||||
}
|
||||
}
|
||||
|
||||
// Make the target observer
|
||||
targetPlayer.setObserving(true);
|
||||
|
||||
// Make the target spectator
|
||||
targetPlayer.sendPacket(ExCuriousHouseObserveMode.STATIC_ENABLED);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.ceremonyofchaos;
|
||||
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosResult;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventMember;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class CeremonyOfChaosMember extends AbstractEventMember<CeremonyOfChaosEvent>
|
||||
{
|
||||
private final int _position;
|
||||
private int _lifeTime = 0;
|
||||
private CeremonyOfChaosResult _resultType = CeremonyOfChaosResult.LOSE;
|
||||
private boolean _isDefeated = false;
|
||||
|
||||
public CeremonyOfChaosMember(PlayerInstance player, CeremonyOfChaosEvent event, int position)
|
||||
{
|
||||
super(player, event);
|
||||
_position = position;
|
||||
}
|
||||
|
||||
public int getPosition()
|
||||
{
|
||||
return _position;
|
||||
}
|
||||
|
||||
public void setLifeTime(int time)
|
||||
{
|
||||
_lifeTime = time;
|
||||
}
|
||||
|
||||
public int getLifeTime()
|
||||
{
|
||||
return _lifeTime;
|
||||
}
|
||||
|
||||
public CeremonyOfChaosResult getResultType()
|
||||
{
|
||||
return _resultType;
|
||||
}
|
||||
|
||||
public void setResultType(CeremonyOfChaosResult resultType)
|
||||
{
|
||||
_resultType = resultType;
|
||||
}
|
||||
|
||||
public boolean isDefeated()
|
||||
{
|
||||
return _isDefeated;
|
||||
}
|
||||
|
||||
public void setDefeated(boolean isDefeated)
|
||||
{
|
||||
_isDefeated = isDefeated;
|
||||
}
|
||||
}
|
||||
@@ -63,7 +63,7 @@ public class ConditionPlayerCanEscape extends Condition
|
||||
{
|
||||
canTeleport = false;
|
||||
}
|
||||
else if (player.isOnCustomEvent())
|
||||
else if (player.isOnEvent())
|
||||
{
|
||||
canTeleport = false;
|
||||
}
|
||||
|
||||
@@ -18,7 +18,6 @@ package org.l2jmobius.gameserver.model.conditions;
|
||||
|
||||
import org.l2jmobius.gameserver.model.actor.Creature;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.effects.EffectFlag;
|
||||
import org.l2jmobius.gameserver.model.items.Item;
|
||||
import org.l2jmobius.gameserver.model.skills.Skill;
|
||||
@@ -61,12 +60,7 @@ public class ConditionPlayerCanSwitchSubclass extends Condition
|
||||
player.sendPacket(SystemMessageId.A_SUBCLASS_CANNOT_BE_CREATED_OR_CHANGED_WHILE_YOU_ARE_OVER_YOUR_WEIGHT_LIMIT);
|
||||
canSwitchSub = false;
|
||||
}
|
||||
else if (player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_CANNOT_CHANGE_YOUR_SUBCLASS_WHILE_REGISTERED_IN_THE_CEREMONY_OF_CHAOS);
|
||||
canSwitchSub = false;
|
||||
}
|
||||
else if (player.isOnEvent())
|
||||
else if (player.isRegisteredOnEvent())
|
||||
{
|
||||
player.sendMessage("You cannot change your subclass while registered in an event.");
|
||||
canSwitchSub = false;
|
||||
|
||||
@@ -64,7 +64,7 @@ public class ConditionPlayerCanTransform extends Condition
|
||||
player.sendPacket(SystemMessageId.YOU_CANNOT_TRANSFORM_WHILE_RIDING_A_PET);
|
||||
canTransform = false;
|
||||
}
|
||||
else if (player.isOnCustomEvent())
|
||||
else if (player.isOnEvent())
|
||||
{
|
||||
player.sendMessage("You cannot transform while registered on an event.");
|
||||
canTransform = false;
|
||||
|
||||
@@ -1,138 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
import java.nio.file.Path;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.events.AbstractScript;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
* @param <T>
|
||||
*/
|
||||
public abstract class AbstractEvent<T extends AbstractEventMember<?>>extends AbstractScript
|
||||
{
|
||||
private final Map<Integer, T> _members = new ConcurrentHashMap<>();
|
||||
private IEventState _state;
|
||||
|
||||
public Map<Integer, T> getMembers()
|
||||
{
|
||||
final Map<Integer, T> members = new HashMap<>();
|
||||
for (Entry<Integer, T> entry : _members.entrySet())
|
||||
{
|
||||
final T member = entry.getValue();
|
||||
if (member != null)
|
||||
{
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if ((player != null) && player.isOnline() && !player.isInOfflineMode())
|
||||
{
|
||||
members.putIfAbsent(entry.getKey(), member);
|
||||
}
|
||||
}
|
||||
}
|
||||
return members;
|
||||
}
|
||||
|
||||
public T getMember(int objectId)
|
||||
{
|
||||
return getMembers().get(objectId);
|
||||
}
|
||||
|
||||
public void addMember(T member)
|
||||
{
|
||||
_members.put(member.getObjectId(), member);
|
||||
}
|
||||
|
||||
public void removeMember(int objectId)
|
||||
{
|
||||
_members.remove(objectId);
|
||||
}
|
||||
|
||||
public void clearMembers()
|
||||
{
|
||||
_members.clear();
|
||||
}
|
||||
|
||||
public void broadcastPacket(IClientOutgoingPacket... packets)
|
||||
{
|
||||
_members.values().forEach(member -> member.sendPacket(packets));
|
||||
}
|
||||
|
||||
public IEventState getState()
|
||||
{
|
||||
return _state;
|
||||
}
|
||||
|
||||
public void setState(IEventState state)
|
||||
{
|
||||
_state = state;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getScriptName()
|
||||
{
|
||||
return getClass().getSimpleName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Path getScriptPath()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player
|
||||
* @return {@code true} if player is on event, {@code false} otherwise.
|
||||
*/
|
||||
public boolean isOnEvent(PlayerInstance player)
|
||||
{
|
||||
return _members.containsKey(player.getObjectId());
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player
|
||||
* @return {@code true} if player is blocked from leaving the game, {@code false} otherwise.
|
||||
*/
|
||||
public boolean isBlockingExit(PlayerInstance player)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player
|
||||
* @return {@code true} if player is blocked from receiving death penalty upon death, {@code false} otherwise.
|
||||
*/
|
||||
public boolean isBlockingDeathPenalty(PlayerInstance player)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param player
|
||||
* @return {@code true} if player can revive after death, {@code false} otherwise.
|
||||
*/
|
||||
public boolean canRevive(PlayerInstance player)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,247 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
import java.nio.file.Path;
|
||||
import java.util.Collections;
|
||||
import java.util.Map;
|
||||
import java.util.Queue;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.ConcurrentLinkedDeque;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
import org.l2jmobius.gameserver.model.StatSet;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.eventengine.drop.IEventDrop;
|
||||
import org.l2jmobius.gameserver.model.events.AbstractScript;
|
||||
import org.l2jmobius.gameserver.model.events.EventType;
|
||||
import org.l2jmobius.gameserver.model.events.ListenerRegisterType;
|
||||
import org.l2jmobius.gameserver.model.events.annotations.RegisterEvent;
|
||||
import org.l2jmobius.gameserver.model.events.annotations.RegisterType;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayerLogout;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
* @param <T>
|
||||
*/
|
||||
public abstract class AbstractEventManager<T extends AbstractEvent<?>>extends AbstractScript
|
||||
{
|
||||
private String _name;
|
||||
private StatSet _variables = StatSet.EMPTY_STATSET;
|
||||
private Set<EventScheduler> _schedulers = Collections.emptySet();
|
||||
private Set<IConditionalEventScheduler> _conditionalSchedulers = Collections.emptySet();
|
||||
private Map<String, IEventDrop> _rewards = Collections.emptyMap();
|
||||
|
||||
private final Set<T> _events = ConcurrentHashMap.newKeySet();
|
||||
private final Queue<PlayerInstance> _registeredPlayers = new ConcurrentLinkedDeque<>();
|
||||
private final AtomicReference<IEventState> _state = new AtomicReference<>();
|
||||
|
||||
public abstract void onInitialized();
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public String getName()
|
||||
{
|
||||
return _name;
|
||||
}
|
||||
|
||||
public void setName(String name)
|
||||
{
|
||||
_name = name;
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public StatSet getVariables()
|
||||
{
|
||||
return _variables;
|
||||
}
|
||||
|
||||
public void setVariables(StatSet variables)
|
||||
{
|
||||
_variables = new StatSet(Collections.unmodifiableMap(variables.getSet()));
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public EventScheduler getScheduler(String name)
|
||||
{
|
||||
for (EventScheduler scheduler : _schedulers)
|
||||
{
|
||||
if (scheduler.getName().equalsIgnoreCase(name))
|
||||
{
|
||||
return scheduler;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public void setSchedulers(Set<EventScheduler> schedulers)
|
||||
{
|
||||
_schedulers = Collections.unmodifiableSet(schedulers);
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public Set<IConditionalEventScheduler> getConditionalSchedulers()
|
||||
{
|
||||
return _conditionalSchedulers;
|
||||
}
|
||||
|
||||
public void setConditionalSchedulers(Set<IConditionalEventScheduler> schedulers)
|
||||
{
|
||||
_conditionalSchedulers = Collections.unmodifiableSet(schedulers);
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public IEventDrop getRewards(String name)
|
||||
{
|
||||
return _rewards.get(name);
|
||||
}
|
||||
|
||||
public void setRewards(Map<String, IEventDrop> rewards)
|
||||
{
|
||||
_rewards = Collections.unmodifiableMap(rewards);
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public Set<T> getEvents()
|
||||
{
|
||||
return _events;
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public void startScheduler()
|
||||
{
|
||||
_schedulers.forEach(EventScheduler::startScheduler);
|
||||
}
|
||||
|
||||
public void stopScheduler()
|
||||
{
|
||||
_schedulers.forEach(EventScheduler::stopScheduler);
|
||||
}
|
||||
|
||||
public void startConditionalSchedulers()
|
||||
{
|
||||
for (IConditionalEventScheduler scheduler : _conditionalSchedulers)
|
||||
{
|
||||
if (scheduler.test())
|
||||
{
|
||||
scheduler.run();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public IEventState getState()
|
||||
{
|
||||
return _state.get();
|
||||
}
|
||||
|
||||
public void setState(IEventState newState)
|
||||
{
|
||||
final IEventState previousState = _state.get();
|
||||
_state.set(newState);
|
||||
onStateChange(previousState, newState);
|
||||
}
|
||||
|
||||
public boolean setState(IEventState previousState, IEventState newState)
|
||||
{
|
||||
if (_state.compareAndSet(previousState, newState))
|
||||
{
|
||||
onStateChange(previousState, newState);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
public boolean registerPlayer(PlayerInstance player)
|
||||
{
|
||||
return canRegister(player, true) && _registeredPlayers.offer(player);
|
||||
}
|
||||
|
||||
public boolean unregisterPlayer(PlayerInstance player)
|
||||
{
|
||||
return _registeredPlayers.remove(player);
|
||||
}
|
||||
|
||||
public boolean isRegistered(PlayerInstance player)
|
||||
{
|
||||
return _registeredPlayers.contains(player);
|
||||
}
|
||||
|
||||
public boolean canRegister(PlayerInstance player, boolean sendMessage)
|
||||
{
|
||||
return !_registeredPlayers.contains(player);
|
||||
}
|
||||
|
||||
public Queue<PlayerInstance> getRegisteredPlayers()
|
||||
{
|
||||
return _registeredPlayers;
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
@RegisterEvent(EventType.ON_PLAYER_LOGOUT)
|
||||
@RegisterType(ListenerRegisterType.GLOBAL)
|
||||
public void OnPlayerLogout(OnPlayerLogout event)
|
||||
{
|
||||
final PlayerInstance player = event.getPlayer();
|
||||
if (_registeredPlayers.remove(player))
|
||||
{
|
||||
onUnregisteredPlayer(player);
|
||||
}
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
|
||||
/**
|
||||
* Triggered when a player is automatically removed from the event manager because he disconnected
|
||||
* @param player
|
||||
*/
|
||||
protected void onUnregisteredPlayer(PlayerInstance player)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Triggered when state is changed
|
||||
* @param previousState
|
||||
* @param newState
|
||||
*/
|
||||
protected void onStateChange(IEventState previousState, IEventState newState)
|
||||
{
|
||||
}
|
||||
|
||||
/* ********************** */
|
||||
@Override
|
||||
public String getScriptName()
|
||||
{
|
||||
return getClass().getSimpleName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Path getScriptPath()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
* @param <T>
|
||||
*/
|
||||
public abstract class AbstractEventMember<T extends AbstractEvent<?>>
|
||||
{
|
||||
private final int _objectId;
|
||||
private final T _event;
|
||||
private final AtomicInteger _score = new AtomicInteger();
|
||||
|
||||
public AbstractEventMember(PlayerInstance player, T event)
|
||||
{
|
||||
_objectId = player.getObjectId();
|
||||
_event = event;
|
||||
}
|
||||
|
||||
public int getObjectId()
|
||||
{
|
||||
return _objectId;
|
||||
}
|
||||
|
||||
public PlayerInstance getPlayer()
|
||||
{
|
||||
return World.getInstance().getPlayer(_objectId);
|
||||
}
|
||||
|
||||
public void sendPacket(IClientOutgoingPacket... packets)
|
||||
{
|
||||
final PlayerInstance player = getPlayer();
|
||||
if ((player != null) && player.isOnline() && !player.isInOfflineMode())
|
||||
{
|
||||
for (IClientOutgoingPacket packet : packets)
|
||||
{
|
||||
player.sendPacket(packet);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int getClassId()
|
||||
{
|
||||
final PlayerInstance player = getPlayer();
|
||||
if (player != null)
|
||||
{
|
||||
return player.getClassId().getId();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
public void setScore(int score)
|
||||
{
|
||||
_score.set(score);
|
||||
}
|
||||
|
||||
public int getScore()
|
||||
{
|
||||
return _score.get();
|
||||
}
|
||||
|
||||
public int incrementScore()
|
||||
{
|
||||
return _score.incrementAndGet();
|
||||
}
|
||||
|
||||
public int decrementScore()
|
||||
{
|
||||
return _score.decrementAndGet();
|
||||
}
|
||||
|
||||
public int addScore(int score)
|
||||
{
|
||||
return _score.addAndGet(score);
|
||||
}
|
||||
|
||||
public T getEvent()
|
||||
{
|
||||
return _event;
|
||||
}
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class EventMethodNotification
|
||||
{
|
||||
private final AbstractEventManager<?> _manager;
|
||||
private final Method _method;
|
||||
private final Object[] _args;
|
||||
|
||||
/**
|
||||
* @param manager
|
||||
* @param methodName
|
||||
* @param args
|
||||
* @throws NoSuchMethodException
|
||||
*/
|
||||
public EventMethodNotification(AbstractEventManager<?> manager, String methodName, List<Object> args) throws NoSuchMethodException
|
||||
{
|
||||
_manager = manager;
|
||||
_method = manager.getClass().getDeclaredMethod(methodName, args.stream().map(Object::getClass).toArray(Class[]::new));
|
||||
_args = args.toArray();
|
||||
}
|
||||
|
||||
public AbstractEventManager<?> getManager()
|
||||
{
|
||||
return _manager;
|
||||
}
|
||||
|
||||
public Method getMethod()
|
||||
{
|
||||
return _method;
|
||||
}
|
||||
|
||||
public void execute() throws Exception
|
||||
{
|
||||
if (Modifier.isStatic(_method.getModifiers()))
|
||||
{
|
||||
invoke(null);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Attempt to find getInstance() method
|
||||
for (Method method : _manager.getClass().getMethods())
|
||||
{
|
||||
if (Modifier.isStatic(method.getModifiers()) && (_manager.getClass().isAssignableFrom(method.getReturnType())) && (method.getParameterCount() == 0))
|
||||
{
|
||||
final Object instance = method.invoke(null);
|
||||
invoke(instance);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void invoke(Object instance) throws Exception
|
||||
{
|
||||
// Java 1.8
|
||||
// final boolean wasAccessible = _method.isAccessible();
|
||||
// Java 10
|
||||
final boolean wasAccessible = _method.canAccess(instance);
|
||||
if (!wasAccessible)
|
||||
{
|
||||
_method.setAccessible(true);
|
||||
}
|
||||
_method.invoke(instance, _args);
|
||||
_method.setAccessible(wasAccessible);
|
||||
}
|
||||
}
|
||||
@@ -1,190 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.Timestamp;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ScheduledFuture;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.l2jmobius.commons.database.DatabaseFactory;
|
||||
import org.l2jmobius.commons.threads.ThreadPool;
|
||||
import org.l2jmobius.commons.util.Chronos;
|
||||
import org.l2jmobius.gameserver.model.StatSet;
|
||||
|
||||
import it.sauronsoftware.cron4j.PastPredictor;
|
||||
import it.sauronsoftware.cron4j.Predictor;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class EventScheduler
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(EventScheduler.class.getName());
|
||||
private final AbstractEventManager<?> _eventManager;
|
||||
private final String _name;
|
||||
private final String _pattern;
|
||||
private final boolean _repeat;
|
||||
private List<EventMethodNotification> _notifications;
|
||||
private ScheduledFuture<?> _task;
|
||||
|
||||
public EventScheduler(AbstractEventManager<?> manager, StatSet set)
|
||||
{
|
||||
_eventManager = manager;
|
||||
_name = set.getString("name", "");
|
||||
_pattern = set.getString("minute", "*") + " " + set.getString("hour", "*") + " " + set.getString("dayOfMonth", "*") + " " + set.getString("month", "*") + " " + set.getString("dayOfWeek", "*");
|
||||
_repeat = set.getBoolean("repeat", false);
|
||||
}
|
||||
|
||||
public String getName()
|
||||
{
|
||||
return _name;
|
||||
}
|
||||
|
||||
public long getNextSchedule()
|
||||
{
|
||||
final Predictor predictor = new Predictor(_pattern);
|
||||
return predictor.nextMatchingTime();
|
||||
}
|
||||
|
||||
public long getNextSchedule(long fromTime)
|
||||
{
|
||||
final Predictor predictor = new Predictor(_pattern, fromTime);
|
||||
return predictor.nextMatchingTime();
|
||||
}
|
||||
|
||||
public long getPrevSchedule()
|
||||
{
|
||||
final PastPredictor predictor = new PastPredictor(_pattern);
|
||||
return predictor.prevMatchingTime();
|
||||
}
|
||||
|
||||
public long getPrevSchedule(long fromTime)
|
||||
{
|
||||
final PastPredictor predictor = new PastPredictor(_pattern, fromTime);
|
||||
return predictor.prevMatchingTime();
|
||||
}
|
||||
|
||||
public boolean isRepeating()
|
||||
{
|
||||
return _repeat;
|
||||
}
|
||||
|
||||
public void addEventNotification(EventMethodNotification notification)
|
||||
{
|
||||
if (_notifications == null)
|
||||
{
|
||||
_notifications = new ArrayList<>();
|
||||
}
|
||||
_notifications.add(notification);
|
||||
}
|
||||
|
||||
public List<EventMethodNotification> getEventNotifications()
|
||||
{
|
||||
return _notifications;
|
||||
}
|
||||
|
||||
public void startScheduler()
|
||||
{
|
||||
if (_notifications == null)
|
||||
{
|
||||
LOGGER.info("Scheduler without notificator manager: " + _eventManager.getClass().getSimpleName() + " pattern: " + _pattern);
|
||||
return;
|
||||
}
|
||||
|
||||
final Predictor predictor = new Predictor(_pattern);
|
||||
final long nextSchedule = predictor.nextMatchingTime();
|
||||
final long timeSchedule = nextSchedule - Chronos.currentTimeMillis();
|
||||
if (timeSchedule <= (30 * 1000))
|
||||
{
|
||||
LOGGER.warning("Wrong reschedule for " + _eventManager.getClass().getSimpleName() + " end up run in " + (timeSchedule / 1000) + " seconds!");
|
||||
ThreadPool.schedule(this::startScheduler, timeSchedule + 1000);
|
||||
return;
|
||||
}
|
||||
|
||||
if (_task != null)
|
||||
{
|
||||
_task.cancel(false);
|
||||
}
|
||||
|
||||
_task = ThreadPool.schedule(() ->
|
||||
{
|
||||
run();
|
||||
updateLastRun();
|
||||
|
||||
if (_repeat)
|
||||
{
|
||||
ThreadPool.schedule(this::startScheduler, 1000);
|
||||
}
|
||||
}, timeSchedule);
|
||||
}
|
||||
|
||||
public boolean updateLastRun()
|
||||
{
|
||||
try (Connection con = DatabaseFactory.getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("INSERT INTO event_schedulers (eventName, schedulerName, lastRun) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE eventName = ?, schedulerName = ?, lastRun = ?"))
|
||||
{
|
||||
ps.setString(1, _eventManager.getName());
|
||||
ps.setString(2, _name);
|
||||
ps.setTimestamp(3, new Timestamp(Chronos.currentTimeMillis()));
|
||||
ps.setString(4, _eventManager.getName());
|
||||
ps.setString(5, _name);
|
||||
ps.setTimestamp(6, new Timestamp(Chronos.currentTimeMillis()));
|
||||
ps.execute();
|
||||
return true;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "Failed to insert/update information for scheduled task manager: " + _eventManager.getClass().getSimpleName() + " scheduler: " + _name, e);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void stopScheduler()
|
||||
{
|
||||
if (_task != null)
|
||||
{
|
||||
_task.cancel(false);
|
||||
_task = null;
|
||||
}
|
||||
}
|
||||
|
||||
public long getRemainingTime(TimeUnit unit)
|
||||
{
|
||||
return (_task != null) && !_task.isDone() ? _task.getDelay(unit) : 0;
|
||||
}
|
||||
|
||||
public void run()
|
||||
{
|
||||
for (EventMethodNotification notification : _notifications)
|
||||
{
|
||||
try
|
||||
{
|
||||
notification.execute();
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
LOGGER.warning("Failed to notify to event manager: " + notification.getManager().getClass().getSimpleName() + " method: " + notification.getMethod().getName());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public interface IConditionalEventScheduler
|
||||
{
|
||||
boolean test();
|
||||
|
||||
void run();
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
@Target(ElementType.METHOD)
|
||||
@Retention(RetentionPolicy.SOURCE)
|
||||
public @interface ScheduleTarget
|
||||
{
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.conditions;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.EventScheduler;
|
||||
import org.l2jmobius.gameserver.model.eventengine.IConditionalEventScheduler;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class BetweenConditionalScheduler implements IConditionalEventScheduler
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(BetweenConditionalScheduler.class.getName());
|
||||
private final AbstractEventManager<?> _eventManager;
|
||||
private final String _name;
|
||||
private final String _scheduler1;
|
||||
private final String _scheduler2;
|
||||
|
||||
public BetweenConditionalScheduler(AbstractEventManager<?> eventManager, String name, String scheduler1, String scheduler2)
|
||||
{
|
||||
Objects.requireNonNull(eventManager);
|
||||
Objects.requireNonNull(name);
|
||||
Objects.requireNonNull(scheduler1);
|
||||
Objects.requireNonNull(scheduler2);
|
||||
|
||||
_eventManager = eventManager;
|
||||
_name = name;
|
||||
_scheduler1 = scheduler1;
|
||||
_scheduler2 = scheduler2;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean test()
|
||||
{
|
||||
final EventScheduler scheduler1 = _eventManager.getScheduler(_scheduler1);
|
||||
final EventScheduler scheduler2 = _eventManager.getScheduler(_scheduler2);
|
||||
if (scheduler1 == null)
|
||||
{
|
||||
throw new NullPointerException("Scheduler1 not found: " + _scheduler1);
|
||||
}
|
||||
else if (scheduler2 == null)
|
||||
{
|
||||
throw new NullPointerException("Scheduler2 not found: " + _scheduler2);
|
||||
}
|
||||
|
||||
final long previousStart = scheduler1.getPrevSchedule();
|
||||
final long previousEnd = scheduler2.getPrevSchedule();
|
||||
return previousStart > previousEnd;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run()
|
||||
{
|
||||
final EventScheduler mainScheduler = _eventManager.getScheduler(_name);
|
||||
if (mainScheduler == null)
|
||||
{
|
||||
throw new NullPointerException("Main scheduler not found: " + _name);
|
||||
}
|
||||
mainScheduler.run();
|
||||
LOGGER.info("Event " + _eventManager.getClass().getSimpleName() + " will resume because is within the event period.");
|
||||
}
|
||||
}
|
||||
@@ -1,91 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.conditions;
|
||||
|
||||
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 org.l2jmobius.commons.database.DatabaseFactory;
|
||||
import org.l2jmobius.gameserver.model.eventengine.AbstractEventManager;
|
||||
import org.l2jmobius.gameserver.model.eventengine.EventScheduler;
|
||||
import org.l2jmobius.gameserver.model.eventengine.IConditionalEventScheduler;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class HaventRunConditionalScheduler implements IConditionalEventScheduler
|
||||
{
|
||||
private static final Logger LOGGER = Logger.getLogger(HaventRunConditionalScheduler.class.getName());
|
||||
private final AbstractEventManager<?> _eventManager;
|
||||
private final String _name;
|
||||
|
||||
public HaventRunConditionalScheduler(AbstractEventManager<?> eventManager, String name)
|
||||
{
|
||||
_eventManager = eventManager;
|
||||
_name = name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean test()
|
||||
{
|
||||
final EventScheduler mainScheduler = _eventManager.getScheduler(_name);
|
||||
if (mainScheduler == null)
|
||||
{
|
||||
throw new NullPointerException("Scheduler not found: " + _name);
|
||||
}
|
||||
|
||||
try (Connection con = DatabaseFactory.getConnection();
|
||||
PreparedStatement ps = con.prepareStatement("SELECT lastRun FROM event_schedulers WHERE eventName = ? AND schedulerName = ?"))
|
||||
{
|
||||
ps.setString(1, _eventManager.getName());
|
||||
ps.setString(2, mainScheduler.getName());
|
||||
try (ResultSet rs = ps.executeQuery())
|
||||
{
|
||||
if (rs.next())
|
||||
{
|
||||
final long lastRun = rs.getTimestamp(1).getTime();
|
||||
final long lastPossibleRun = mainScheduler.getPrevSchedule();
|
||||
return (lastPossibleRun > lastRun) && (Math.abs(lastPossibleRun - lastRun) > 1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SQLException e)
|
||||
{
|
||||
LOGGER.log(Level.WARNING, "Failed to retreive information for scheduled task event manager: " + _eventManager.getClass().getSimpleName() + " scheduler: " + _name, e);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run()
|
||||
{
|
||||
final EventScheduler mainScheduler = _eventManager.getScheduler(_name);
|
||||
if (mainScheduler == null)
|
||||
{
|
||||
throw new NullPointerException("Scheduler not found: " + _name);
|
||||
}
|
||||
|
||||
if (mainScheduler.updateLastRun())
|
||||
{
|
||||
mainScheduler.run();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.drop;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class EventDropGroup
|
||||
{
|
||||
private final List<EventDropItem> _items = new ArrayList<>();
|
||||
private final double _chance;
|
||||
|
||||
public EventDropGroup(double chance)
|
||||
{
|
||||
_chance = chance;
|
||||
}
|
||||
|
||||
public double getChance()
|
||||
{
|
||||
return _chance;
|
||||
}
|
||||
|
||||
public List<EventDropItem> getItems()
|
||||
{
|
||||
return _items;
|
||||
}
|
||||
|
||||
public void addItem(EventDropItem item)
|
||||
{
|
||||
_items.add(item);
|
||||
}
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.drop;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class EventDropItem
|
||||
{
|
||||
private final int _id;
|
||||
private final int _min;
|
||||
private final int _max;
|
||||
private final double _chance;
|
||||
|
||||
public EventDropItem(int id, int min, int max, double chance)
|
||||
{
|
||||
_id = id;
|
||||
_min = min;
|
||||
_max = max;
|
||||
_chance = chance;
|
||||
}
|
||||
|
||||
public int getId()
|
||||
{
|
||||
return _id;
|
||||
}
|
||||
|
||||
public int getMin()
|
||||
{
|
||||
return _min;
|
||||
}
|
||||
|
||||
public int getMax()
|
||||
{
|
||||
return _max;
|
||||
}
|
||||
|
||||
public double getChance()
|
||||
{
|
||||
return _chance;
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.drop;
|
||||
|
||||
import java.util.function.Supplier;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public enum EventDrops
|
||||
{
|
||||
GROUPED(GroupedDrop::new),
|
||||
NORMAL(NormalDrop::new);
|
||||
|
||||
private final Supplier<? extends IEventDrop> _supplier;
|
||||
|
||||
private EventDrops(Supplier<IEventDrop> supplier)
|
||||
{
|
||||
_supplier = supplier;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T extends IEventDrop> T newInstance()
|
||||
{
|
||||
return (T) (_supplier.get());
|
||||
}
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.drop;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
import org.l2jmobius.commons.util.Rnd;
|
||||
import org.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class GroupedDrop implements IEventDrop
|
||||
{
|
||||
private final List<EventDropGroup> _groups = new ArrayList<>();
|
||||
|
||||
public List<EventDropGroup> getGroups()
|
||||
{
|
||||
return _groups;
|
||||
}
|
||||
|
||||
public void addGroup(EventDropGroup group)
|
||||
{
|
||||
_groups.add(group);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Collection<ItemHolder> calculateDrops()
|
||||
{
|
||||
final List<ItemHolder> rewards = new ArrayList<>();
|
||||
for (EventDropGroup group : _groups)
|
||||
{
|
||||
if ((Rnd.nextDouble() * 100) < group.getChance())
|
||||
{
|
||||
double totalChance = 0;
|
||||
final double random = (Rnd.nextDouble() * 100);
|
||||
for (EventDropItem item : group.getItems())
|
||||
{
|
||||
totalChance += item.getChance();
|
||||
if (totalChance > random)
|
||||
{
|
||||
final long count = Rnd.get(item.getMin(), item.getMax());
|
||||
if (count > 0)
|
||||
{
|
||||
rewards.add(new ItemHolder(item.getId(), count));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return rewards;
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.drop;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
import org.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public interface IEventDrop
|
||||
{
|
||||
Collection<ItemHolder> calculateDrops();
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.eventengine.drop;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
import org.l2jmobius.commons.util.Rnd;
|
||||
import org.l2jmobius.gameserver.model.holders.ItemHolder;
|
||||
|
||||
/**
|
||||
* @author UnAfraid
|
||||
*/
|
||||
public class NormalDrop implements IEventDrop
|
||||
{
|
||||
private final List<EventDropItem> _items = new ArrayList<>();
|
||||
|
||||
public List<EventDropItem> getItems()
|
||||
{
|
||||
return _items;
|
||||
}
|
||||
|
||||
public void addItem(EventDropItem item)
|
||||
{
|
||||
_items.add(item);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Collection<ItemHolder> calculateDrops()
|
||||
{
|
||||
final List<ItemHolder> rewards = new ArrayList<>();
|
||||
double totalChance = 0;
|
||||
final double random = (Rnd.nextDouble() * 100);
|
||||
for (EventDropItem item : _items)
|
||||
{
|
||||
totalChance += item.getChance();
|
||||
if (totalChance > random)
|
||||
{
|
||||
final long count = Rnd.get(item.getMin(), item.getMax());
|
||||
if (count > 0)
|
||||
{
|
||||
rewards.add(new ItemHolder(item.getId(), count));
|
||||
}
|
||||
}
|
||||
}
|
||||
return rewards;
|
||||
}
|
||||
}
|
||||
@@ -18,7 +18,7 @@ package org.l2jmobius.gameserver.model.events.impl.ceremonyofchaos;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosMember;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.events.EventType;
|
||||
import org.l2jmobius.gameserver.model.events.impl.IBaseEvent;
|
||||
|
||||
@@ -27,21 +27,21 @@ import org.l2jmobius.gameserver.model.events.impl.IBaseEvent;
|
||||
*/
|
||||
public class OnCeremonyOfChaosMatchResult implements IBaseEvent
|
||||
{
|
||||
private final List<CeremonyOfChaosMember> _winners;
|
||||
private final List<CeremonyOfChaosMember> _members;
|
||||
private final List<PlayerInstance> _winners;
|
||||
private final List<PlayerInstance> _members;
|
||||
|
||||
public OnCeremonyOfChaosMatchResult(List<CeremonyOfChaosMember> winners, List<CeremonyOfChaosMember> members)
|
||||
public OnCeremonyOfChaosMatchResult(List<PlayerInstance> winners, List<PlayerInstance> members)
|
||||
{
|
||||
_winners = winners;
|
||||
_members = members;
|
||||
}
|
||||
|
||||
public List<CeremonyOfChaosMember> getWinners()
|
||||
public List<PlayerInstance> getWinners()
|
||||
{
|
||||
return _winners;
|
||||
}
|
||||
|
||||
public List<CeremonyOfChaosMember> getMembers()
|
||||
public List<PlayerInstance> getMembers()
|
||||
{
|
||||
return _members;
|
||||
}
|
||||
|
||||
@@ -1,109 +0,0 @@
|
||||
/*
|
||||
* 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 org.l2jmobius.gameserver.model.holders;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import org.l2jmobius.Config;
|
||||
import org.l2jmobius.gameserver.data.sql.CharNameTable;
|
||||
import org.l2jmobius.gameserver.data.sql.ClanTable;
|
||||
import org.l2jmobius.gameserver.model.Location;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
|
||||
/**
|
||||
* Player event holder, meant for restoring player after event has finished.<br>
|
||||
* Allows you to restore following information about player:
|
||||
* <ul>
|
||||
* <li>Name</li>
|
||||
* <li>Title</li>
|
||||
* <li>Clan</li>
|
||||
* <li>Location</li>
|
||||
* <li>PvP Kills</li>
|
||||
* <li>PK Kills</li>
|
||||
* <li>Karma</li>
|
||||
* </ul>
|
||||
* @author Nik, xban1x
|
||||
*/
|
||||
public class PlayerEventHolder
|
||||
{
|
||||
private final PlayerInstance _player;
|
||||
private final String _name;
|
||||
private final String _title;
|
||||
private final int _clanId;
|
||||
private final Location _loc;
|
||||
private final int _pvpKills;
|
||||
private final int _pkKills;
|
||||
private final int _reputation;
|
||||
|
||||
private final Map<PlayerInstance, Integer> _kills = new ConcurrentHashMap<>();
|
||||
private boolean _sitForced;
|
||||
|
||||
public PlayerEventHolder(PlayerInstance player)
|
||||
{
|
||||
this(player, false);
|
||||
}
|
||||
|
||||
public PlayerEventHolder(PlayerInstance player, boolean sitForced)
|
||||
{
|
||||
_player = player;
|
||||
_name = player.getName();
|
||||
_title = player.getTitle();
|
||||
_clanId = player.getClanId();
|
||||
_loc = new Location(player);
|
||||
_pvpKills = player.getPvpKills();
|
||||
_pkKills = player.getPkKills();
|
||||
_reputation = player.getReputation();
|
||||
_sitForced = sitForced;
|
||||
}
|
||||
|
||||
public void restorePlayerStats()
|
||||
{
|
||||
_player.setName(_name);
|
||||
if (Config.CACHE_CHAR_NAMES)
|
||||
{
|
||||
CharNameTable.getInstance().addName(_player);
|
||||
}
|
||||
_player.setTitle(_title);
|
||||
_player.setClan(ClanTable.getInstance().getClan(_clanId));
|
||||
_player.teleToLocation(_loc, true);
|
||||
_player.setPvpKills(_pvpKills);
|
||||
_player.setPkKills(_pkKills);
|
||||
_player.setReputation(_reputation);
|
||||
}
|
||||
|
||||
public void setSitForced(boolean sitForced)
|
||||
{
|
||||
_sitForced = sitForced;
|
||||
}
|
||||
|
||||
public boolean isSitForced()
|
||||
{
|
||||
return _sitForced;
|
||||
}
|
||||
|
||||
public Map<PlayerInstance, Integer> getKills()
|
||||
{
|
||||
return Collections.unmodifiableMap(_kills);
|
||||
}
|
||||
|
||||
public void addKill(PlayerInstance player)
|
||||
{
|
||||
_kills.merge(player, 1, Integer::sum);
|
||||
}
|
||||
}
|
||||
@@ -978,7 +978,7 @@ public class Instance implements IIdentifiable, INamable
|
||||
*/
|
||||
public void onDeath(PlayerInstance player)
|
||||
{
|
||||
if (!player.isOnCustomEvent() && (_template.getEjectTime() > 0))
|
||||
if (!player.isOnEvent() && (_template.getEjectTime() > 0))
|
||||
{
|
||||
// Send message
|
||||
final SystemMessage sm = new SystemMessage(SystemMessageId.IF_YOU_ARE_NOT_RESURRECTED_WITHIN_S1_MINUTE_S_YOU_WILL_BE_EXPELLED_FROM_THE_INSTANT_ZONE);
|
||||
|
||||
@@ -37,7 +37,6 @@ import org.l2jmobius.gameserver.model.PlayerCondOverride;
|
||||
import org.l2jmobius.gameserver.model.StatSet;
|
||||
import org.l2jmobius.gameserver.model.WorldObject;
|
||||
import org.l2jmobius.gameserver.model.actor.Creature;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.commission.CommissionItemType;
|
||||
import org.l2jmobius.gameserver.model.conditions.Condition;
|
||||
import org.l2jmobius.gameserver.model.events.ListenersContainer;
|
||||
@@ -146,7 +145,7 @@ public abstract class Item extends ListenersContainer implements IIdentifiable
|
||||
private boolean _freightable;
|
||||
private boolean _allowSelfResurrection;
|
||||
private boolean _isOlyRestricted;
|
||||
private boolean _isCocRestricted;
|
||||
private boolean _isEventRestricted;
|
||||
private boolean _forNpc;
|
||||
private boolean _common;
|
||||
private boolean _heroItem;
|
||||
@@ -219,7 +218,7 @@ public abstract class Item extends ListenersContainer implements IIdentifiable
|
||||
_freightable = set.getBoolean("is_freightable", false);
|
||||
_allowSelfResurrection = set.getBoolean("allow_self_resurrection", false);
|
||||
_isOlyRestricted = set.getBoolean("is_oly_restricted", false);
|
||||
_isCocRestricted = set.getBoolean("is_coc_restricted", false);
|
||||
_isEventRestricted = set.getBoolean("is_event_restricted", false);
|
||||
_forNpc = set.getBoolean("for_npc", false);
|
||||
_isAppearanceable = set.getBoolean("isAppearanceable", false);
|
||||
_isBlessed = set.getBoolean("blessed", false);
|
||||
@@ -854,9 +853,9 @@ public abstract class Item extends ListenersContainer implements IIdentifiable
|
||||
return false;
|
||||
}
|
||||
|
||||
if (_isCocRestricted && (creature.isPlayer() && (creature.getActingPlayer().isOnEvent(CeremonyOfChaosEvent.class))))
|
||||
if (_isEventRestricted && (creature.isPlayer() && (creature.getActingPlayer().isOnEvent())))
|
||||
{
|
||||
creature.sendPacket(SystemMessageId.YOU_CANNOT_USE_THIS_ITEM_IN_THE_TOURNAMENT);
|
||||
creature.sendMessage("You cannot use this item in the event.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -931,11 +930,11 @@ public abstract class Item extends ListenersContainer implements IIdentifiable
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {@code true} if item cannot be used in Ceremony of Chaos games.
|
||||
* @return {@code true} if item cannot be used in event games.
|
||||
*/
|
||||
public boolean isCocRestrictedItem()
|
||||
public boolean isEventRestrictedItem()
|
||||
{
|
||||
return _isCocRestricted;
|
||||
return _isEventRestricted;
|
||||
}
|
||||
|
||||
public boolean isForNpc()
|
||||
|
||||
@@ -221,9 +221,9 @@ public class OlympiadManager
|
||||
{
|
||||
case CLASSED:
|
||||
{
|
||||
if (player.isOnEvent())
|
||||
if (player.isRegisteredOnEvent())
|
||||
{
|
||||
player.sendMessage("You can't join olympiad while participating on an Event.");
|
||||
player.sendMessage("You can't join olympiad while participating on an event.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -242,9 +242,9 @@ public class OlympiadManager
|
||||
}
|
||||
case NON_CLASSED:
|
||||
{
|
||||
if (player.isOnEvent())
|
||||
if (player.isRegisteredOnEvent())
|
||||
{
|
||||
player.sendMessage("You can't join olympiad while participating on TvT Event.");
|
||||
player.sendMessage("You can't join olympiad while participating on an event.");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@@ -25,7 +25,6 @@ import java.util.Comparator;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
@@ -33,7 +32,6 @@ import org.l2jmobius.commons.database.DatabaseFactory;
|
||||
import org.l2jmobius.commons.util.Chronos;
|
||||
import org.l2jmobius.gameserver.data.sql.ClanTable;
|
||||
import org.l2jmobius.gameserver.data.xml.ClanHallData;
|
||||
import org.l2jmobius.gameserver.instancemanager.ClanHallAuctionManager;
|
||||
import org.l2jmobius.gameserver.model.clan.Clan;
|
||||
import org.l2jmobius.gameserver.model.itemcontainer.Inventory;
|
||||
|
||||
@@ -186,9 +184,4 @@ public class ClanHallAuction
|
||||
{
|
||||
return _clanHallId;
|
||||
}
|
||||
|
||||
public long getRemaingTime()
|
||||
{
|
||||
return ClanHallAuctionManager.getInstance().getScheduler("endAuction").getRemainingTime(TimeUnit.MILLISECONDS);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1122,7 +1122,7 @@ public class SkillCaster implements Runnable
|
||||
}
|
||||
|
||||
// Events.
|
||||
if (player.isOnCustomEvent())
|
||||
if (player.isOnEvent())
|
||||
{
|
||||
if (skill.hasEffectType(EffectType.TELEPORT)) // Disable teleport skills.
|
||||
{
|
||||
|
||||
@@ -45,7 +45,6 @@ import org.l2jmobius.gameserver.instancemanager.PetitionManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.PunishmentManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.ServerRestartManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.SiegeManager;
|
||||
import org.l2jmobius.gameserver.instancemanager.events.GameEvent;
|
||||
import org.l2jmobius.gameserver.model.PlayerCondOverride;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.WorldObject;
|
||||
@@ -424,11 +423,6 @@ public class EnterWorld implements IClientIncomingPacket
|
||||
player.sendPacket(new ExRotation(player.getObjectId(), player.getHeading()));
|
||||
player.getInventory().applyItemSkills();
|
||||
|
||||
if (GameEvent.isParticipant(player))
|
||||
{
|
||||
GameEvent.restorePlayerEventStatus(player);
|
||||
}
|
||||
|
||||
if (player.isCursedWeaponEquipped())
|
||||
{
|
||||
CursedWeaponsManager.getInstance().getCursedWeapon(player.getCursedWeaponEquippedId()).cursedOnLogin();
|
||||
|
||||
@@ -26,7 +26,6 @@ import org.l2jmobius.gameserver.model.Party;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.actor.request.PartyRequest;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ActionFailed;
|
||||
@@ -120,13 +119,7 @@ public class RequestJoinParty implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
if (requestor.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
{
|
||||
client.sendPacket(SystemMessageId.YOU_CANNOT_INVITE_A_FRIEND_OR_PARTY_WHILE_PARTICIPATING_IN_THE_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
|
||||
if (requestor.isOnEvent()) // custom event message
|
||||
if (requestor.isRegisteredOnEvent())
|
||||
{
|
||||
requestor.sendMessage("You cannot invite to a party while participating in an event.");
|
||||
return;
|
||||
|
||||
@@ -30,9 +30,7 @@ import org.l2jmobius.gameserver.model.TradeList;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.WorldObject;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ActionFailed;
|
||||
import org.l2jmobius.gameserver.util.Util;
|
||||
|
||||
@@ -87,14 +85,7 @@ public class RequestPrivateStoreBuy implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
// Cannot set private store in Ceremony of Chaos event.
|
||||
if (player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
{
|
||||
client.sendPacket(SystemMessageId.YOU_CANNOT_OPEN_A_PRIVATE_STORE_OR_WORKSHOP_IN_THE_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
|
||||
if (player.isOnEvent()) // custom event message
|
||||
if (player.isRegisteredOnEvent())
|
||||
{
|
||||
player.sendMessage("You cannot open a private store while participating in an event.");
|
||||
return;
|
||||
|
||||
@@ -26,9 +26,7 @@ import org.l2jmobius.gameserver.model.ItemRequest;
|
||||
import org.l2jmobius.gameserver.model.TradeList;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ActionFailed;
|
||||
|
||||
public class RequestPrivateStoreSell implements IClientIncomingPacket
|
||||
@@ -92,14 +90,7 @@ public class RequestPrivateStoreSell implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
// Cannot set private store in Ceremony of Chaos event.
|
||||
if (player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
{
|
||||
client.sendPacket(SystemMessageId.YOU_CANNOT_OPEN_A_PRIVATE_STORE_OR_WORKSHOP_IN_THE_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
|
||||
if (player.isOnEvent()) // custom event message
|
||||
if (player.isRegisteredOnEvent())
|
||||
{
|
||||
player.sendMessage("You cannot open a private store while participating in an event.");
|
||||
return;
|
||||
|
||||
@@ -95,7 +95,7 @@ public class RequestRestartPoint implements IClientIncomingPacket
|
||||
}
|
||||
|
||||
// Custom event resurrection management.
|
||||
if (player.isOnCustomEvent())
|
||||
if (player.isOnEvent())
|
||||
{
|
||||
for (AbstractEventListener listener : player.getListeners(EventType.ON_CREATURE_DEATH))
|
||||
{
|
||||
|
||||
@@ -24,7 +24,6 @@ import org.l2jmobius.gameserver.enums.ChatType;
|
||||
import org.l2jmobius.gameserver.handler.ChatHandler;
|
||||
import org.l2jmobius.gameserver.handler.IChatHandler;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.effects.EffectFlag;
|
||||
import org.l2jmobius.gameserver.model.events.EventDispatcher;
|
||||
import org.l2jmobius.gameserver.model.events.impl.creature.player.OnPlayerChat;
|
||||
@@ -162,12 +161,6 @@ public class Say2 implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
if (player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_CANNOT_CHAT_IN_THE_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
|
||||
if (player.isJailed() && Config.JAIL_DISABLE_CHAT && ((chatType == ChatType.WHISPER) || (chatType == ChatType.SHOUT) || (chatType == ChatType.TRADE) || (chatType == ChatType.HERO_VOICE)))
|
||||
{
|
||||
player.sendMessage("You can not chat with players outside of the jail.");
|
||||
|
||||
@@ -28,7 +28,6 @@ import org.l2jmobius.gameserver.data.xml.SkillData;
|
||||
import org.l2jmobius.gameserver.data.xml.SkillTreeData;
|
||||
import org.l2jmobius.gameserver.model.SkillLearn;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.holders.SkillHolder;
|
||||
import org.l2jmobius.gameserver.model.skills.Skill;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
@@ -95,12 +94,12 @@ public class RequestAcquireAbilityList implements IClientIncomingPacket
|
||||
player.sendPacket(SystemMessageId.REACH_LEVEL_85_TO_USE_THE_ABILITY);
|
||||
return;
|
||||
}
|
||||
else if (player.isInOlympiadMode() || player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
else if (player.isInOlympiadMode())
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_CANNOT_USE_OR_RESET_ABILITY_POINTS_WHILE_PARTICIPATING_IN_THE_OLYMPIAD_OR_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
else if (player.isOnEvent()) // custom event message
|
||||
else if (player.isOnEvent())
|
||||
{
|
||||
player.sendMessage("You cannot use or reset Ability Points while participating in an event.");
|
||||
return;
|
||||
|
||||
@@ -23,7 +23,6 @@ import org.l2jmobius.gameserver.enums.PrivateStoreType;
|
||||
import org.l2jmobius.gameserver.enums.SkillFinishType;
|
||||
import org.l2jmobius.gameserver.model.SkillLearn;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.skills.Skill;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
@@ -64,12 +63,12 @@ public class RequestResetAbilityPoint implements IClientIncomingPacket
|
||||
client.sendPacket(SystemMessageId.REACH_LEVEL_85_TO_USE_THE_ABILITY);
|
||||
return;
|
||||
}
|
||||
else if (player.isInOlympiadMode() || player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
else if (player.isInOlympiadMode())
|
||||
{
|
||||
client.sendPacket(SystemMessageId.YOU_CANNOT_USE_OR_RESET_ABILITY_POINTS_WHILE_PARTICIPATING_IN_THE_OLYMPIAD_OR_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
else if (player.isOnEvent()) // custom event message
|
||||
else if (player.isOnEvent())
|
||||
{
|
||||
player.sendMessage("You cannot use or reset Ability Points while participating in an event.");
|
||||
return;
|
||||
|
||||
@@ -17,13 +17,9 @@
|
||||
package org.l2jmobius.gameserver.network.clientpackets.ceremonyofchaos;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketReader;
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosState;
|
||||
import org.l2jmobius.gameserver.instancemanager.CeremonyOfChaosManager;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.clientpackets.IClientIncomingPacket;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseState;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
@@ -46,15 +42,15 @@ public class RequestCancelCuriousHouse implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
if (CeremonyOfChaosManager.getInstance().unregisterPlayer(player))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_HAVE_BEEN_TAKEN_OFF_THE_WAIT_LIST_YOU_MAY_ONLY_ENTER_THE_WAIT_LIST_ON_MON_THURS_EVERY_QUARTER_OF_AN_HOUR_FOR_5_MINUTES_BETWEEN_20_00_AND_23_40_IF_YOU_CANCEL_REGISTRATION_OR_CHOOSE_TO_FORFEIT_AFTER_ENTERING_A_MATCH_30_TIMES_OR_MORE_DURING_A_CYCLE_YOU_MUST_WAIT_UNTIL_THE_NEXT_CYCLE_TO_PARTICIPATE_IN_THE_CEREMONY_OF_CHAOS_UPON_ENTERING_THE_ARENA_ALL_BUFFS_EXCLUDING_VITALITY_BUFFS_ARE_REMOVED);
|
||||
player.sendPacket(ExCuriousHouseState.IDLE_PACKET);
|
||||
|
||||
if (CeremonyOfChaosManager.getInstance().getState() == CeremonyOfChaosState.PREPARING_FOR_TELEPORT)
|
||||
{
|
||||
player.prohibiteCeremonyOfChaos();
|
||||
}
|
||||
}
|
||||
// if (CeremonyOfChaosManager.getInstance().unregisterPlayer(player))
|
||||
// {
|
||||
// player.sendPacket(SystemMessageId.YOU_HAVE_BEEN_TAKEN_OFF_THE_WAIT_LIST_YOU_MAY_ONLY_ENTER_THE_WAIT_LIST_ON_MON_THURS_EVERY_QUARTER_OF_AN_HOUR_FOR_5_MINUTES_BETWEEN_20_00_AND_23_40_IF_YOU_CANCEL_REGISTRATION_OR_CHOOSE_TO_FORFEIT_AFTER_ENTERING_A_MATCH_30_TIMES_OR_MORE_DURING_A_CYCLE_YOU_MUST_WAIT_UNTIL_THE_NEXT_CYCLE_TO_PARTICIPATE_IN_THE_CEREMONY_OF_CHAOS_UPON_ENTERING_THE_ARENA_ALL_BUFFS_EXCLUDING_VITALITY_BUFFS_ARE_REMOVED);
|
||||
// player.sendPacket(ExCuriousHouseState.IDLE_PACKET);
|
||||
//
|
||||
// if (CeremonyOfChaosManager.getInstance().getState() == CeremonyOfChaosState.PREPARING_FOR_TELEPORT)
|
||||
// {
|
||||
// player.prohibiteCeremonyOfChaos();
|
||||
// }
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,13 +17,9 @@
|
||||
package org.l2jmobius.gameserver.network.clientpackets.ceremonyofchaos;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketReader;
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosState;
|
||||
import org.l2jmobius.gameserver.instancemanager.CeremonyOfChaosManager;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.clientpackets.IClientIncomingPacket;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.NpcHtmlMessage;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
@@ -46,21 +42,21 @@ public class RequestCuriousHouseHtml implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
if (CeremonyOfChaosManager.getInstance().getState() != CeremonyOfChaosState.REGISTRATION)
|
||||
{
|
||||
return;
|
||||
}
|
||||
else if (CeremonyOfChaosManager.getInstance().isRegistered(player))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_ARE_ON_THE_WAITING_LIST_FOR_THE_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
|
||||
if (CeremonyOfChaosManager.getInstance().canRegister(player, true))
|
||||
{
|
||||
final NpcHtmlMessage message = new NpcHtmlMessage(0);
|
||||
message.setFile(player, "data/html/CeremonyOfChaos/invite.htm");
|
||||
player.sendPacket(message);
|
||||
}
|
||||
// if (CeremonyOfChaosManager.getInstance().getState() != CeremonyOfChaosState.REGISTRATION)
|
||||
// {
|
||||
// return;
|
||||
// }
|
||||
// else if (CeremonyOfChaosManager.getInstance().isRegistered(player))
|
||||
// {
|
||||
// player.sendPacket(SystemMessageId.YOU_ARE_ON_THE_WAITING_LIST_FOR_THE_CEREMONY_OF_CHAOS);
|
||||
// return;
|
||||
// }
|
||||
//
|
||||
// if (CeremonyOfChaosManager.getInstance().canRegister(player, true))
|
||||
// {
|
||||
// final NpcHtmlMessage message = new NpcHtmlMessage(0);
|
||||
// message.setFile(player, "data/html/CeremonyOfChaos/invite.htm");
|
||||
// player.sendPacket(message);
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,13 +17,9 @@
|
||||
package org.l2jmobius.gameserver.network.clientpackets.ceremonyofchaos;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketReader;
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosState;
|
||||
import org.l2jmobius.gameserver.instancemanager.CeremonyOfChaosManager;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.clientpackets.IClientIncomingPacket;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos.ExCuriousHouseState;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
@@ -46,25 +42,25 @@ public class RequestJoinCuriousHouse implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
if (CeremonyOfChaosManager.getInstance().getState() != CeremonyOfChaosState.REGISTRATION)
|
||||
{
|
||||
return;
|
||||
}
|
||||
else if (CeremonyOfChaosManager.getInstance().isRegistered(player))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_ARE_ON_THE_WAITING_LIST_FOR_THE_CEREMONY_OF_CHAOS);
|
||||
return;
|
||||
}
|
||||
|
||||
if (CeremonyOfChaosManager.getInstance().registerPlayer(player))
|
||||
{
|
||||
player.sendPacket(SystemMessageId.YOU_ARE_NOW_ON_THE_WAITING_LIST_YOU_WILL_AUTOMATICALLY_BE_TELEPORTED_WHEN_THE_TOURNAMENT_STARTS_AND_WILL_BE_REMOVED_FROM_THE_WAITING_LIST_IF_YOU_LOG_OUT_IF_YOU_CANCEL_REGISTRATION_WITHIN_THE_LAST_MINUTE_OF_ENTERING_THE_ARENA_AFTER_SIGNING_UP_30_TIMES_OR_MORE_OR_FORFEIT_AFTER_ENTERING_THE_ARENA_30_TIMES_OR_MORE_DURING_A_CYCLE_YOU_BECOME_INELIGIBLE_FOR_PARTICIPATION_IN_THE_CEREMONY_OF_CHAOS_UNTIL_THE_NEXT_CYCLE_ALL_THE_BUFFS_EXCEPT_THE_VITALITY_BUFF_WILL_BE_REMOVED_ONCE_YOU_ENTER_THE_ARENAS);
|
||||
player.sendPacket(SystemMessageId.EXCEPT_THE_VITALITY_BUFF_ALL_BUFFS_INCLUDING_ART_OF_SEDUCTION_WILL_BE_DELETED);
|
||||
player.sendPacket(ExCuriousHouseState.PREPARE_PACKET);
|
||||
}
|
||||
else
|
||||
{
|
||||
player.sendPacket(SystemMessageId.THERE_ARE_TOO_MANY_CHALLENGERS_YOU_CANNOT_PARTICIPATE_NOW);
|
||||
}
|
||||
// if (CeremonyOfChaosManager.getInstance().getState() != CeremonyOfChaosState.REGISTRATION)
|
||||
// {
|
||||
// return;
|
||||
// }
|
||||
// else if (CeremonyOfChaosManager.getInstance().isRegistered(player))
|
||||
// {
|
||||
// player.sendPacket(SystemMessageId.YOU_ARE_ON_THE_WAITING_LIST_FOR_THE_CEREMONY_OF_CHAOS);
|
||||
// return;
|
||||
// }
|
||||
//
|
||||
// if (CeremonyOfChaosManager.getInstance().registerPlayer(player))
|
||||
// {
|
||||
// player.sendPacket(SystemMessageId.YOU_ARE_NOW_ON_THE_WAITING_LIST_YOU_WILL_AUTOMATICALLY_BE_TELEPORTED_WHEN_THE_TOURNAMENT_STARTS_AND_WILL_BE_REMOVED_FROM_THE_WAITING_LIST_IF_YOU_LOG_OUT_IF_YOU_CANCEL_REGISTRATION_WITHIN_THE_LAST_MINUTE_OF_ENTERING_THE_ARENA_AFTER_SIGNING_UP_30_TIMES_OR_MORE_OR_FORFEIT_AFTER_ENTERING_THE_ARENA_30_TIMES_OR_MORE_DURING_A_CYCLE_YOU_BECOME_INELIGIBLE_FOR_PARTICIPATION_IN_THE_CEREMONY_OF_CHAOS_UNTIL_THE_NEXT_CYCLE_ALL_THE_BUFFS_EXCEPT_THE_VITALITY_BUFF_WILL_BE_REMOVED_ONCE_YOU_ENTER_THE_ARENAS);
|
||||
// player.sendPacket(SystemMessageId.EXCEPT_THE_VITALITY_BUFF_ALL_BUFFS_INCLUDING_ART_OF_SEDUCTION_WILL_BE_DELETED);
|
||||
// player.sendPacket(ExCuriousHouseState.PREPARE_PACKET);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// player.sendPacket(SystemMessageId.THERE_ARE_TOO_MANY_CHALLENGERS_YOU_CANNOT_PARTICIPATE_NOW);
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,7 +22,6 @@ import org.l2jmobius.gameserver.data.xml.FakePlayerData;
|
||||
import org.l2jmobius.gameserver.model.BlockList;
|
||||
import org.l2jmobius.gameserver.model.World;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.network.GameClient;
|
||||
import org.l2jmobius.gameserver.network.SystemMessageId;
|
||||
import org.l2jmobius.gameserver.network.clientpackets.IClientIncomingPacket;
|
||||
@@ -98,10 +97,10 @@ public class RequestFriendInvite implements IClientIncomingPacket
|
||||
return;
|
||||
}
|
||||
|
||||
// Cannot request friendship in Ceremony of Chaos event.
|
||||
if (player.isOnEvent(CeremonyOfChaosEvent.class))
|
||||
// Cannot request friendship in an event.
|
||||
if (player.isOnEvent())
|
||||
{
|
||||
client.sendPacket(SystemMessageId.YOU_CANNOT_INVITE_A_FRIEND_OR_PARTY_WHILE_PARTICIPATING_IN_THE_CEREMONY_OF_CHAOS);
|
||||
player.sendMessage("You cannot request friendship while participating in an event.");
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -24,8 +24,6 @@ import org.l2jmobius.gameserver.instancemanager.CursedWeaponsManager;
|
||||
import org.l2jmobius.gameserver.model.VariationInstance;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.DecoyInstance;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosMember;
|
||||
import org.l2jmobius.gameserver.model.clan.Clan;
|
||||
import org.l2jmobius.gameserver.model.interfaces.ILocational;
|
||||
import org.l2jmobius.gameserver.model.itemcontainer.Inventory;
|
||||
@@ -121,8 +119,6 @@ public class CharInfo implements IClientOutgoingPacket
|
||||
public boolean write(PacketWriter packet)
|
||||
{
|
||||
OutgoingPackets.CHAR_INFO.writeId(packet);
|
||||
final CeremonyOfChaosEvent event = _player.getEvent(CeremonyOfChaosEvent.class);
|
||||
final CeremonyOfChaosMember cocPlayer = event != null ? event.getMember(_player.getObjectId()) : null;
|
||||
packet.writeC(0x00); // Grand Crusade
|
||||
packet.writeD(_x); // Confirmed
|
||||
packet.writeD(_y); // Confirmed
|
||||
@@ -265,7 +261,7 @@ public class CharInfo implements IClientOutgoingPacket
|
||||
{
|
||||
packet.writeH(AbnormalVisualEffect.STEALTH.getClientId());
|
||||
}
|
||||
packet.writeC(cocPlayer != null ? cocPlayer.getPosition() : _player.isTrueHero() ? 100 : 0);
|
||||
packet.writeC(_player.isTrueHero() ? 100 : 0);
|
||||
packet.writeC(_player.isHairAccessoryEnabled() ? 0x01 : 0x00); // Hair accessory
|
||||
packet.writeC(_player.getAbilityPointsUsed()); // Used Ability Points
|
||||
return true;
|
||||
|
||||
@@ -18,7 +18,6 @@ package org.l2jmobius.gameserver.network.serverpackets.appearance;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketWriter;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosMember;
|
||||
import org.l2jmobius.gameserver.network.OutgoingPackets;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
|
||||
@@ -33,24 +32,13 @@ public class ExCuriousHouseMemberUpdate implements IClientOutgoingPacket
|
||||
public int _currentHp;
|
||||
public int _currentCp;
|
||||
|
||||
public ExCuriousHouseMemberUpdate(CeremonyOfChaosMember member)
|
||||
public ExCuriousHouseMemberUpdate(PlayerInstance player)
|
||||
{
|
||||
_objId = member.getObjectId();
|
||||
final PlayerInstance player = member.getPlayer();
|
||||
if (player != null)
|
||||
{
|
||||
_maxHp = player.getMaxHp();
|
||||
_maxCp = player.getMaxCp();
|
||||
_currentHp = (int) player.getCurrentHp();
|
||||
_currentCp = (int) player.getCurrentCp();
|
||||
}
|
||||
else
|
||||
{
|
||||
_maxHp = 0;
|
||||
_maxCp = 0;
|
||||
_currentHp = 0;
|
||||
_currentCp = 0;
|
||||
}
|
||||
_objId = player.getObjectId();
|
||||
_maxHp = player.getMaxHp();
|
||||
_maxCp = player.getMaxCp();
|
||||
_currentHp = (int) player.getCurrentHp();
|
||||
_currentCp = (int) player.getCurrentCp();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -20,7 +20,6 @@ import java.util.Collection;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketWriter;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosMember;
|
||||
import org.l2jmobius.gameserver.network.OutgoingPackets;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
|
||||
@@ -31,9 +30,9 @@ public class ExCuriousHouseMemberList implements IClientOutgoingPacket
|
||||
{
|
||||
private final int _id;
|
||||
private final int _maxPlayers;
|
||||
private final Collection<CeremonyOfChaosMember> _players;
|
||||
private final Collection<PlayerInstance> _players;
|
||||
|
||||
public ExCuriousHouseMemberList(int id, int maxPlayers, Collection<CeremonyOfChaosMember> players)
|
||||
public ExCuriousHouseMemberList(int id, int maxPlayers, Collection<PlayerInstance> players)
|
||||
{
|
||||
_id = id;
|
||||
_maxPlayers = maxPlayers;
|
||||
@@ -48,25 +47,14 @@ public class ExCuriousHouseMemberList implements IClientOutgoingPacket
|
||||
packet.writeD(_id);
|
||||
packet.writeD(_maxPlayers);
|
||||
packet.writeD(_players.size());
|
||||
for (CeremonyOfChaosMember cocPlayer : _players)
|
||||
for (PlayerInstance player : _players)
|
||||
{
|
||||
final PlayerInstance player = cocPlayer.getPlayer();
|
||||
packet.writeD(cocPlayer.getObjectId());
|
||||
packet.writeD(cocPlayer.getPosition());
|
||||
if (player != null)
|
||||
{
|
||||
packet.writeD(player.getMaxHp());
|
||||
packet.writeD(player.getMaxCp());
|
||||
packet.writeD((int) player.getCurrentHp());
|
||||
packet.writeD((int) player.getCurrentCp());
|
||||
}
|
||||
else
|
||||
{
|
||||
packet.writeD(0x00);
|
||||
packet.writeD(0x00);
|
||||
packet.writeD(0x00);
|
||||
packet.writeD(0x00);
|
||||
}
|
||||
packet.writeD(player.getObjectId());
|
||||
packet.writeD(0x00); // cocPlayer.getPosition
|
||||
packet.writeD(player.getMaxHp());
|
||||
packet.writeD(player.getMaxCp());
|
||||
packet.writeD((int) player.getCurrentHp());
|
||||
packet.writeD((int) player.getCurrentCp());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -16,10 +16,11 @@
|
||||
*/
|
||||
package org.l2jmobius.gameserver.network.serverpackets.ceremonyofchaos;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketWriter;
|
||||
import org.l2jmobius.gameserver.enums.CeremonyOfChaosResult;
|
||||
import org.l2jmobius.gameserver.instancemanager.CeremonyOfChaosManager;
|
||||
import org.l2jmobius.gameserver.model.ceremonyofchaos.CeremonyOfChaosEvent;
|
||||
import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.network.OutgoingPackets;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
|
||||
@@ -29,30 +30,30 @@ import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
public class ExCuriousHouseResult implements IClientOutgoingPacket
|
||||
{
|
||||
private final CeremonyOfChaosResult _result;
|
||||
private final CeremonyOfChaosEvent _event;
|
||||
private final Collection<PlayerInstance> _players;
|
||||
|
||||
public ExCuriousHouseResult(CeremonyOfChaosResult result, CeremonyOfChaosEvent event)
|
||||
public ExCuriousHouseResult(CeremonyOfChaosResult result, Collection<PlayerInstance> players)
|
||||
{
|
||||
_result = result;
|
||||
_event = event;
|
||||
_players = players;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean write(PacketWriter packet)
|
||||
{
|
||||
OutgoingPackets.EX_CURIOUS_HOUSE_RESULT.writeId(packet);
|
||||
packet.writeD(_event.getId());
|
||||
packet.writeD(0); // _event.getId()
|
||||
packet.writeH(_result.ordinal());
|
||||
packet.writeD(CeremonyOfChaosManager.getInstance().getMaxPlayersInArena());
|
||||
packet.writeD(_event.getMembers().size());
|
||||
_event.getMembers().values().forEach(m ->
|
||||
packet.writeD(_players.size()); // CeremonyOfChaosManager.getInstance().getMaxPlayersInArena()
|
||||
packet.writeD(_players.size());
|
||||
for (PlayerInstance player : _players)
|
||||
{
|
||||
packet.writeD(m.getObjectId());
|
||||
packet.writeD(m.getPosition());
|
||||
packet.writeD(m.getClassId());
|
||||
packet.writeD(m.getLifeTime());
|
||||
packet.writeD(m.getScore());
|
||||
});
|
||||
packet.writeD(player.getObjectId());
|
||||
packet.writeD(0x00); // cocPlayer.getPosition
|
||||
packet.writeD(player.getClassId().getId());
|
||||
packet.writeD(0x00); // getLifeTime
|
||||
packet.writeD(0x00); // getScore
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,9 +19,9 @@ package org.l2jmobius.gameserver.network.serverpackets.dailymission;
|
||||
import java.time.LocalDate;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.function.Function;
|
||||
|
||||
import org.l2jmobius.commons.network.PacketWriter;
|
||||
import org.l2jmobius.commons.time.SchedulingPattern;
|
||||
import org.l2jmobius.commons.util.Chronos;
|
||||
import org.l2jmobius.gameserver.data.xml.DailyMissionData;
|
||||
import org.l2jmobius.gameserver.model.DailyMissionDataHolder;
|
||||
@@ -29,28 +29,28 @@ import org.l2jmobius.gameserver.model.actor.instance.PlayerInstance;
|
||||
import org.l2jmobius.gameserver.network.OutgoingPackets;
|
||||
import org.l2jmobius.gameserver.network.serverpackets.IClientOutgoingPacket;
|
||||
|
||||
import it.sauronsoftware.cron4j.Predictor;
|
||||
|
||||
/**
|
||||
* @author Sdw
|
||||
*/
|
||||
public class ExOneDayReceiveRewardList implements IClientOutgoingPacket
|
||||
{
|
||||
final PlayerInstance _player;
|
||||
private final Collection<DailyMissionDataHolder> _rewards;
|
||||
private static final Function<String, Long> _remainTime = pattern -> (new Predictor(pattern).nextMatchingTime() - Chronos.currentTimeMillis()) / 1000;
|
||||
private static final SchedulingPattern DAILY_REUSE_PATTERN = new SchedulingPattern("30 6 * * *");
|
||||
private static final SchedulingPattern WEEKLY_REUSE_PATTERN = new SchedulingPattern("30 6 * * 1");
|
||||
private static final SchedulingPattern MONTHLY_REUSE_PATTERN = new SchedulingPattern("30 6 1 * *");
|
||||
|
||||
private final long _dayRemainTime;
|
||||
private final long _weekRemainTime;
|
||||
private final long _monthRemainTime;
|
||||
private final PlayerInstance _player;
|
||||
private final Collection<DailyMissionDataHolder> _rewards;
|
||||
private final int _dayRemainTime;
|
||||
private final int _weekRemainTime;
|
||||
private final int _monthRemainTime;
|
||||
|
||||
public ExOneDayReceiveRewardList(PlayerInstance player, boolean sendRewards)
|
||||
{
|
||||
_player = player;
|
||||
_rewards = sendRewards ? DailyMissionData.getInstance().getDailyMissionData(player) : Collections.emptyList();
|
||||
_dayRemainTime = _remainTime.apply("30 6 * * *");
|
||||
_weekRemainTime = _remainTime.apply("30 6 * * 1");
|
||||
_monthRemainTime = _remainTime.apply("30 6 1 * *");
|
||||
_dayRemainTime = (int) ((DAILY_REUSE_PATTERN.next(Chronos.currentTimeMillis()) - Chronos.currentTimeMillis()) / 1000);
|
||||
_weekRemainTime = (int) ((WEEKLY_REUSE_PATTERN.next(Chronos.currentTimeMillis()) - Chronos.currentTimeMillis()) / 1000);
|
||||
_monthRemainTime = (int) ((MONTHLY_REUSE_PATTERN.next(Chronos.currentTimeMillis()) - Chronos.currentTimeMillis()) / 1000);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -63,9 +63,9 @@ public class ExOneDayReceiveRewardList implements IClientOutgoingPacket
|
||||
|
||||
OutgoingPackets.EX_ONE_DAY_RECEIVE_REWARD_LIST.writeId(packet);
|
||||
|
||||
packet.writeD((int) _dayRemainTime);
|
||||
packet.writeD((int) _weekRemainTime);
|
||||
packet.writeD((int) _monthRemainTime);
|
||||
packet.writeD(_dayRemainTime);
|
||||
packet.writeD(_weekRemainTime);
|
||||
packet.writeD(_monthRemainTime);
|
||||
packet.writeC(0x17);
|
||||
packet.writeD(_player.getClassId().getId());
|
||||
packet.writeD(LocalDate.now().getDayOfWeek().ordinal()); // Day of week
|
||||
|
||||
@@ -48,7 +48,7 @@ public class OfflineTradeUtil
|
||||
*/
|
||||
private static boolean offlineMode(PlayerInstance player)
|
||||
{
|
||||
if ((player == null) || player.isInOlympiadMode() || player.isBlockedFromExit() || player.isJailed() || (player.getVehicle() != null))
|
||||
if ((player == null) || player.isInOlympiadMode() || player.isRegisteredOnEvent() || player.isJailed() || (player.getVehicle() != null))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user