mirror of
https://github.com/ProjectSWGCore/NGECore2.git
synced 2026-10-05 20:12:51 -04:00
386 lines
15 KiB
Java
386 lines
15 KiB
Java
/*******************************************************************************
|
|
* Copyright (c) 2013 <Project SWG>
|
|
*
|
|
* This File is part of NGECore2.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Using NGEngine to work with NGECore2 is making a combined work based on NGEngine.
|
|
* Therefore all terms and conditions of the GNU Lesser General Public License cover the combination.
|
|
******************************************************************************/
|
|
package services.playercities;
|
|
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.Map;
|
|
import java.util.Random;
|
|
import java.util.Vector;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.ScheduledExecutorService;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import resources.common.OutOfBand;
|
|
import resources.common.ProsePackage;
|
|
import resources.datatables.Citizenship;
|
|
import resources.objects.building.BuildingObject;
|
|
import resources.objects.creature.CreatureObject;
|
|
import resources.objects.tangible.TangibleObject;
|
|
import services.chat.Mail;
|
|
import services.sui.SUIWindow;
|
|
import services.sui.SUIWindow.SUICallback;
|
|
import services.sui.SUIWindow.Trigger;
|
|
import engine.resources.objects.SWGObject;
|
|
import engine.resources.scene.Planet;
|
|
import engine.resources.scene.Point3D;
|
|
import engine.resources.service.INetworkDispatch;
|
|
import engine.resources.service.INetworkRemoteEvent;
|
|
import main.NGECore;
|
|
|
|
/**
|
|
* @author Charon
|
|
*/
|
|
|
|
public class PlayerCityService implements INetworkDispatch {
|
|
|
|
private NGECore core;
|
|
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
|
|
private Random random = new Random();
|
|
private Vector<PlayerCity> playerCities = new Vector<PlayerCity>();
|
|
private int cityID = 0; // This must be persisted or handled via objectservice somehow
|
|
private Map<String, int[]> cityRankCaps = new ConcurrentHashMap<String, int[]>();
|
|
// static helper variable to be deleted later
|
|
public static boolean sandboxCityBuilt = false;
|
|
|
|
public PlayerCityService(NGECore core) {
|
|
this.core = core;
|
|
}
|
|
|
|
public void loadCityRankCaps() {
|
|
core.scriptService.callScript("scripts/", "cityRankCaps", "addCityRankCaps", core);
|
|
}
|
|
|
|
public void addCityRankCap(String planetName, int[] caps) {
|
|
cityRankCaps.put(planetName, caps);
|
|
}
|
|
|
|
public boolean isRankCapped(Planet planet, int rank) {
|
|
if(cityRankCaps.get(planet.getName()) == null)
|
|
return true;
|
|
int cap = cityRankCaps.get(planet.getName())[rank - 1];
|
|
return playerCities.stream().filter(c -> c.getPlanetId() == planet.getID()).count() >= cap;
|
|
}
|
|
|
|
private long generateCityId() {
|
|
boolean found = false;
|
|
long id = 0;
|
|
while(!found) {
|
|
id = random.nextLong();
|
|
final long cityId = id;
|
|
if(!playerCities.stream().filter(c -> c.getCityID() == cityId).findFirst().isPresent())
|
|
found = true;
|
|
}
|
|
return id;
|
|
}
|
|
|
|
private boolean doesCityNameExist(String name) {
|
|
return playerCities.stream().map(PlayerCity::getCityName).filter(n -> n.equalsIgnoreCase(name)).findFirst().isPresent() ||
|
|
core.terrainService.getClientRegions().stream().map(ClientRegion::getName).filter(n -> n.equalsIgnoreCase(name)).findFirst().isPresent();
|
|
}
|
|
|
|
public void handlePlaceCity(final CreatureObject actor, TangibleObject deed, float positionX, float positionZ, float rotation) {
|
|
|
|
if(!canPlacePlayerCityAtPosition(actor, actor.getPlanet(), new Point3D(positionX, 0, positionZ)))
|
|
return;
|
|
|
|
if(isRankCapped(actor.getPlanet(), PlayerCity.OUTPOST)) {
|
|
actor.sendSystemMessage("This Planet can not support any more cities.", (byte) 0);
|
|
return;
|
|
}
|
|
|
|
if(actor.getPlayerObject().getCitizenship() == Citizenship.Mayor) {
|
|
actor.sendSystemMessage("@city/city:already_mayor", (byte) 0);
|
|
return;
|
|
}
|
|
|
|
final SUIWindow window = core.suiService.createInputBox(2,"@city/city:city_name_t","@city/city:city_name_d", actor, null, 0);
|
|
core.suiService.openSUIWindow(window);
|
|
Vector<String> returnList = new Vector<String>();
|
|
returnList.add("txtInput:LocalText");
|
|
window.addHandler(0, "", Trigger.TRIGGER_OK, returnList, new SUICallback() {
|
|
@Override
|
|
public void process(SWGObject owner, int eventType, Vector<String> returnList) {
|
|
if (returnList.size() == 0 || returnList.get(0).length() == 0)
|
|
return;
|
|
String name = returnList.get(0);
|
|
if(!core.characterService.checkName(name, owner.getClient())) {
|
|
actor.sendSystemMessage("@player_structure:not_valid_name", (byte) 0);
|
|
return;
|
|
}
|
|
if(doesCityNameExist(name)) {
|
|
actor.sendSystemMessage("@player_structure:cityname_not_unique", (byte) 0);
|
|
return;
|
|
}
|
|
|
|
BuildingObject cityHall = core.housingService.placeStructure(actor, deed, positionX, positionZ, rotation);
|
|
|
|
if(cityHall == null) {
|
|
actor.sendSystemMessage("Error: NULL city hall", (byte) 0);
|
|
return;
|
|
}
|
|
|
|
PlayerCity playerCity = addNewPlayerCity(actor, cityHall);
|
|
PlayerCityService.this.schedulePlayerCityUpdate(playerCity, PlayerCity.newCityGraceSpan);
|
|
cityHall.setAttachment("structureCity", playerCity.getCityID());
|
|
actor.setAttachment("residentCity", playerCity.getCityID());
|
|
core.housingService.declareResidency(actor, cityHall);
|
|
newCitySUI2((CreatureObject) owner, playerCity);
|
|
|
|
}
|
|
});
|
|
core.suiService.openSUIWindow(window);
|
|
|
|
}
|
|
|
|
public PlayerCity addNewPlayerCity(CreatureObject founder, BuildingObject cityHall) {
|
|
PlayerCity newCity = null;
|
|
synchronized(playerCities){
|
|
newCity = new PlayerCity(founder, generateCityId(), cityHall);
|
|
playerCities.add(newCity);
|
|
}
|
|
return newCity;
|
|
}
|
|
|
|
public PlayerCity getCityObjectIsIn(SWGObject object) {
|
|
PlayerCity foundCity = null;
|
|
synchronized(playerCities){
|
|
for (PlayerCity city : playerCities){
|
|
int radius = city.getCityRadius();
|
|
float distance = object.getWorldPosition().getDistance2D(city.getCityCenterPosition());
|
|
if (distance<radius){
|
|
foundCity = city;
|
|
}
|
|
}
|
|
}
|
|
return foundCity;
|
|
}
|
|
|
|
public PlayerCity getPlayerCity(CreatureObject citizen) {
|
|
PlayerCity foundCity = null;
|
|
synchronized(playerCities){
|
|
for (PlayerCity city : playerCities){
|
|
int id = (int)citizen.getAttachment("residentCity");
|
|
if (city.getCityID()==id){
|
|
foundCity = city;
|
|
}
|
|
}
|
|
}
|
|
return foundCity;
|
|
}
|
|
|
|
public boolean canPlacePlayerCityAtPosition(CreatureObject actor, Planet planet, Point3D position) {
|
|
|
|
PlayerCity closest = playerCities.stream().min((c1, c2) -> (int) (c1.getCityCenterPosition().getDistance2D(position) - c2.getCityCenterPosition().getDistance2D(position))).orElse(null);
|
|
if(closest != null && closest.getCityCenterPosition().getDistance2D(position) < 1024) {
|
|
actor.sendSystemMessage(OutOfBand.ProsePackage("@player_structure:city_too_close", "TO", closest.getCityName()), (byte) 0);
|
|
return false;
|
|
}
|
|
ClientRegion closest2 = core.terrainService.getClientRegionsForPlanet(planet).stream().min((c1, c2) -> (int) (c1.getCenter().getDistance2D(position) - c2.getCenter().getDistance2D(position))).orElse(null);
|
|
if(closest2 != null && closest2.getCenter().getDistance2D(position) < 1024) {
|
|
actor.sendSystemMessage(OutOfBand.ProsePackage("@player_structure:city_too_close", "TO", closest2.getName()), (byte) 0);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void newCitySUI1(CreatureObject citizen, final PlayerCity newCity) {
|
|
final SUIWindow window = core.suiService.createInputBox(2,"@city/city:city_name_t","@city/city:city_name_d", citizen, citizen, 0);
|
|
core.suiService.openSUIWindow(window);
|
|
Vector<String> returnList = new Vector<String>();
|
|
returnList.add("txtInput:LocalText");
|
|
window.addHandler(0, "", Trigger.TRIGGER_OK, returnList, new SUICallback() {
|
|
@Override
|
|
public void process(SWGObject owner, int eventType, Vector<String> returnList) {
|
|
if (returnList.size()==0)
|
|
return;
|
|
PlayerCity playerCity = main.NGECore.getInstance().playerCityService.getPlayerCity((CreatureObject) owner);
|
|
playerCity.setCityName(returnList.get(0));
|
|
//owner.sendSystemMessage("@city/city:name_changed", 0);
|
|
core.suiService.closeSUIWindow(owner, 0);
|
|
newCitySUI2((CreatureObject) owner, playerCity);
|
|
}
|
|
});
|
|
core.suiService.openSUIWindow(window);
|
|
}
|
|
|
|
public void newCitySUI2(CreatureObject citizen, final PlayerCity newCity) {
|
|
final SUIWindow window = core.suiService.createSUIWindow("Script.messageBox", citizen, citizen, 0);
|
|
window.setProperty("bg.caption.lblTitle:Text", "@city/city:rank0");
|
|
window.setProperty("Prompt.lblPrompt:Text", "@city/city:new_city_body");
|
|
window.setProperty("btnOk:visible", "True");
|
|
window.setProperty("btnCancel:visible", "True");
|
|
window.setProperty("btnOk:Text", "@ok");
|
|
window.setProperty("btnCancel:Text", "@cancel");
|
|
Vector<String> returnList = new Vector<String>();
|
|
window.addHandler(0, "", Trigger.TRIGGER_OK, returnList, new SUICallback() {
|
|
@Override
|
|
public void process(SWGObject owner, int eventType, Vector<String> returnList) {
|
|
core.suiService.closeSUIWindow(owner, 0);
|
|
}
|
|
});
|
|
core.suiService.openSUIWindow(window);
|
|
}
|
|
|
|
|
|
// Test method to be deleted later
|
|
public void buildSandboxTestCity(CreatureObject founder) {
|
|
|
|
if (sandboxCityBuilt)
|
|
return;
|
|
|
|
float positionX = 2170.0F;
|
|
float positionY = 1.0F;
|
|
float positionZ = -4659.0F;
|
|
|
|
String structureTemplate = "object/building/player/city/shared_cityhall_tatooine.iff";
|
|
|
|
BuildingObject cityHall = (BuildingObject) core.objectService.createObject(structureTemplate, 0, founder.getPlanet(), new Point3D(positionX, positionY, positionZ), founder.getOrientation());
|
|
core.simulationService.add(cityHall, cityHall.getPosition().x, cityHall.getPosition().z, true);
|
|
|
|
SWGObject sign = core.objectService.createChildObject((SWGObject)cityHall, "object/tangible/sign/player/shared_house_address.iff", -7.39F, 2.36F, 2, -1, 0, -1);
|
|
cityHall.setAttachment("structureSign", sign);
|
|
|
|
PlayerCity sandboxCity = null;
|
|
synchronized(playerCities){
|
|
sandboxCity = new PlayerCity(founder,cityID++, cityHall);
|
|
sandboxCity.setCityName("Sandbox City");
|
|
playerCities.add(sandboxCity);
|
|
}
|
|
|
|
cityHall.setAttachment("structureCity", sandboxCity.getCityID());
|
|
founder.setAttachment("residentCity", sandboxCity.getCityID());
|
|
// Name the sign
|
|
// TangibleObject sign = (TangibleObject) cityHall.getAttachment("structureSign");
|
|
// String playerFirstName = founder.getCustomName().split(" ")[0];
|
|
//
|
|
// if (sign !=null)
|
|
// sign.setCustomName2(playerFirstName + "'s House");
|
|
|
|
|
|
|
|
// Structure management
|
|
Vector<Long> admins = new Vector<>();
|
|
admins.add(founder.getObjectID());
|
|
|
|
cityHall.setAttachment("structureOwner", founder.getObjectID());
|
|
cityHall.setAttachment("structureAdmins", admins);
|
|
cityHall.setDeedTemplate("object/tangible/deed/city_deed/shared_cityhall_tatooine_deed.iff");
|
|
cityHall.setBMR(325);
|
|
cityHall.setConditionDamage(100);
|
|
|
|
|
|
positionY = core.terrainService.getHeight(founder.getPlanetId(), positionX, positionZ);
|
|
founder.setPosition(new Point3D(positionX,positionY,positionZ+50));
|
|
core.simulationService.teleport(founder, new Point3D(positionX,positionY,positionZ+50), founder.getOrientation(), 0);
|
|
|
|
TangibleObject swoopDeed = (TangibleObject) core.objectService.createObject("object/tangible/deed/vehicle_deed/shared_speederbike_swoop_deed.iff", founder.getPlanet());
|
|
SWGObject inventory = founder.getSlottedObject("inventory");
|
|
inventory.add(swoopDeed);
|
|
|
|
TangibleObject shuttleportDeed = (TangibleObject) core.objectService.createObject("object/tangible/deed/city_deed/shared_shuttleport_tatooine_deed.iff", founder.getPlanet());
|
|
inventory.add(shuttleportDeed);
|
|
|
|
TangibleObject garden1 = (TangibleObject) core.objectService.createObject("object/tangible/deed/city_deed/shared_garden_tatooine_sml_01_deed.iff", founder.getPlanet());
|
|
inventory.add(garden1);
|
|
|
|
|
|
//structureTemplate = "object/building/player/city/shared_shuttleport_tatooine.iff";
|
|
structureTemplate = "object/building/tatooine/shared_shuttleport_tatooine.iff";
|
|
positionX = 2170.0F;
|
|
positionY = 1.0F;
|
|
positionZ = -4559.0F;
|
|
positionY = core.terrainService.getHeight(founder.getPlanetId(), positionX, positionZ);
|
|
|
|
//StructureObject shuttlePort = (StructureObject) core.objectService.createObject(structureTemplate, 0, founder.getPlanet(), new Point3D(positionX, positionY, positionZ), founder.getOrientation());
|
|
//BuildingObject shuttlePort = (BuildingObject) core.objectService.createObject(structureTemplate, 0, founder.getPlanet(), new Point3D(positionX, positionY, positionZ), founder.getOrientation());
|
|
//shuttlePort.setAttachment("cellsSorted", new Boolean(true));
|
|
//"bigSpawnRange"
|
|
|
|
//core.simulationService.add(shuttlePort, shuttlePort.getPosition().x, shuttlePort.getPosition().z, true);
|
|
// sign = core.objectService.createChildObject((SWGObject)shuttlePort, "object/tangible/sign/player/shared_house_address.iff", -7.39F, 2.36F, 2, -1, 0, -1);
|
|
// shuttlePort.setAttachment("structureSign", sign);
|
|
|
|
// Structure management
|
|
admins = new Vector<>();
|
|
admins.add(founder.getObjectID());
|
|
|
|
// shuttlePort.setAttachment("structureOwner", founder.getObjectID());
|
|
// shuttlePort.setAttachment("structureAdmins", admins);
|
|
// shuttlePort.setDeedTemplate("object/tangible/deed/city_deed/shared_cityhall_tatooine_deed.iff");
|
|
// shuttlePort.setBMR(12);
|
|
// shuttlePort.setConditionDamage(100);
|
|
|
|
sandboxCityBuilt = true;
|
|
}
|
|
|
|
|
|
@Override
|
|
public void insertOpcodes(Map<Integer, INetworkRemoteEvent> arg0,
|
|
Map<Integer, INetworkRemoteEvent> arg1) {
|
|
// TODO Auto-generated method stub
|
|
|
|
}
|
|
|
|
@Override
|
|
public void shutdown() {
|
|
// TODO Auto-generated method stub
|
|
|
|
}
|
|
|
|
public void destroyCity(PlayerCity city) {
|
|
|
|
CreatureObject mayor = core.objectService.getObject(city.getMayorID()) == null ? core.objectService.getCreatureFromDB(city.getMayorID()) : (CreatureObject) core.objectService.getObject(city.getMayorID());
|
|
if(mayor == null)
|
|
return;
|
|
|
|
Mail mail = new Mail();
|
|
mail.setMailId(NGECore.getInstance().chatService.generateMailId());
|
|
mail.setRecieverId(city.getMayorID());
|
|
mail.setStatus(Mail.NEW);
|
|
mail.setTimeStamp((int) (new Date().getTime() / 1000));
|
|
mail.setSubject("@city/city:new_city_fail_subject");
|
|
mail.setSenderName("@city/city:new_city_from");
|
|
mail.setMessage("@city/city:new_city_fail_body");
|
|
|
|
if(mayor.getClient() != null)
|
|
core.chatService.sendPersistentMessageHeader(mayor.getClient(), mail);
|
|
core.chatService.storePersistentMessage(mail);
|
|
for(long civicStructureId : new Vector<Long>(city.getPlacedStructures())) {
|
|
BuildingObject civicStructure = (BuildingObject) core.objectService.getObject(civicStructureId);
|
|
if(civicStructure == null)
|
|
continue;
|
|
core.housingService.destroyStructure(civicStructure);
|
|
}
|
|
|
|
playerCities.remove(city);
|
|
|
|
}
|
|
|
|
public void schedulePlayerCityUpdate(PlayerCity playerCity, long time) {
|
|
scheduler.schedule(() -> {
|
|
playerCity.processCityUpdate();
|
|
}, time, TimeUnit.MILLISECONDS);
|
|
}
|
|
}
|