mirror of
https://github.com/Grasscutters/Grasscutter.git
synced 2026-05-22 03:19:50 +08:00
KingRainbow44
daa51e53b7
NOT completely finished, nor is it completely done. Protocol issues remain! (including lack of packet IDs)
598 lines
21 KiB
Java
598 lines
21 KiB
Java
package emu.grasscutter.scripts;
|
|
|
|
import emu.grasscutter.database.DatabaseHelper;
|
|
import emu.grasscutter.game.dungeons.challenge.DungeonChallenge;
|
|
import emu.grasscutter.game.dungeons.challenge.factory.ChallengeFactory;
|
|
import emu.grasscutter.game.entity.EntityGadget;
|
|
import emu.grasscutter.game.entity.EntityMonster;
|
|
import emu.grasscutter.game.entity.GameEntity;
|
|
import emu.grasscutter.game.entity.gadget.GadgetWorktop;
|
|
import emu.grasscutter.game.player.Player;
|
|
import emu.grasscutter.game.props.EntityType;
|
|
import emu.grasscutter.game.quest.enums.QuestState;
|
|
import emu.grasscutter.game.quest.enums.QuestTrigger;
|
|
import emu.grasscutter.scripts.data.SceneGroup;
|
|
import emu.grasscutter.server.packet.send.PacketCanUseSkillNotify;
|
|
import emu.grasscutter.server.packet.send.PacketDungeonShowReminderNotify;
|
|
import emu.grasscutter.server.packet.send.PacketWorktopOptionNotify;
|
|
import io.netty.util.concurrent.FastThreadLocal;
|
|
import java.util.Optional;
|
|
import org.luaj.vm2.LuaTable;
|
|
import org.luaj.vm2.LuaValue;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
public class ScriptLib {
|
|
public static final Logger logger = LoggerFactory.getLogger(ScriptLib.class);
|
|
private final FastThreadLocal<SceneScriptManager> sceneScriptManager;
|
|
private final FastThreadLocal<SceneGroup> currentGroup;
|
|
|
|
public ScriptLib() {
|
|
this.sceneScriptManager = new FastThreadLocal<>();
|
|
this.currentGroup = new FastThreadLocal<>();
|
|
}
|
|
|
|
public void removeSceneScriptManager() {
|
|
this.sceneScriptManager.remove();
|
|
}
|
|
|
|
public SceneScriptManager getSceneScriptManager() {
|
|
// normally not null
|
|
return Optional.of(sceneScriptManager.get()).get();
|
|
}
|
|
|
|
public void setSceneScriptManager(SceneScriptManager sceneScriptManager) {
|
|
this.sceneScriptManager.set(sceneScriptManager);
|
|
}
|
|
|
|
private String printTable(LuaTable table) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("{");
|
|
for (var meta : table.keys()) {
|
|
sb.append(meta).append(":").append(table.get(meta)).append(",");
|
|
}
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
public Optional<SceneGroup> getCurrentGroup() {
|
|
return Optional.of(this.currentGroup.get());
|
|
}
|
|
|
|
public void setCurrentGroup(SceneGroup currentGroup) {
|
|
this.currentGroup.set(currentGroup);
|
|
}
|
|
|
|
public void removeCurrentGroup() {
|
|
this.currentGroup.remove();
|
|
}
|
|
|
|
public int SetGadgetStateByConfigId(int configId, int gadgetState) {
|
|
logger.debug("[LUA] Call SetGadgetStateByConfigId with {},{}", configId, gadgetState);
|
|
Optional<GameEntity> entity =
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(e -> e.getConfigId() == configId)
|
|
.findFirst();
|
|
|
|
if (entity.isEmpty()) {
|
|
return 1;
|
|
}
|
|
|
|
if (entity.get() instanceof EntityGadget entityGadget) {
|
|
entityGadget.updateState(gadgetState);
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
public int SetGroupGadgetStateByConfigId(int groupId, int configId, int gadgetState) {
|
|
logger.debug(
|
|
"[LUA] Call SetGroupGadgetStateByConfigId with {},{},{}", groupId, configId, gadgetState);
|
|
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(e -> e.getGroupId() == groupId)
|
|
.filter(e -> e instanceof EntityGadget)
|
|
.map(e -> (EntityGadget) e)
|
|
.forEach(e -> e.updateState(gadgetState));
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int SetWorktopOptionsByGroupId(int groupId, int configId, int[] options) {
|
|
logger.debug("[LUA] Call SetWorktopOptionsByGroupId with {},{},{}", groupId, configId, options);
|
|
|
|
Optional<GameEntity> entity =
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(e -> e.getConfigId() == configId && e.getGroupId() == groupId)
|
|
.findFirst();
|
|
|
|
if (entity.isEmpty() || !(entity.get() instanceof EntityGadget gadget)) {
|
|
return 1;
|
|
}
|
|
|
|
if (!(gadget.getContent() instanceof GadgetWorktop worktop)) {
|
|
return 1;
|
|
}
|
|
|
|
worktop.addWorktopOptions(options);
|
|
getSceneScriptManager().getScene().broadcastPacket(new PacketWorktopOptionNotify(gadget));
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int SetWorktopOptions(LuaTable table) {
|
|
logger.debug("[LUA] Call SetWorktopOptions with {}", printTable(table));
|
|
// TODO
|
|
return 0;
|
|
}
|
|
|
|
public int DelWorktopOptionByGroupId(int groupId, int configId, int option) {
|
|
logger.debug("[LUA] Call DelWorktopOptionByGroupId with {},{},{}", groupId, configId, option);
|
|
|
|
Optional<GameEntity> entity =
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(e -> e.getConfigId() == configId && e.getGroupId() == groupId)
|
|
.findFirst();
|
|
|
|
if (entity.isEmpty() || !(entity.get() instanceof EntityGadget gadget)) {
|
|
return 1;
|
|
}
|
|
|
|
if (!(gadget.getContent() instanceof GadgetWorktop worktop)) {
|
|
return 1;
|
|
}
|
|
|
|
worktop.removeWorktopOption(option);
|
|
getSceneScriptManager().getScene().broadcastPacket(new PacketWorktopOptionNotify(gadget));
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Some fields are guessed
|
|
public int AutoMonsterTide(
|
|
int challengeIndex,
|
|
int groupId,
|
|
Integer[] ordersConfigId,
|
|
int tideCount,
|
|
int sceneLimit,
|
|
int param6) {
|
|
logger.debug(
|
|
"[LUA] Call AutoMonsterTide with {},{},{},{},{},{}",
|
|
challengeIndex,
|
|
groupId,
|
|
ordersConfigId,
|
|
tideCount,
|
|
sceneLimit,
|
|
param6);
|
|
|
|
SceneGroup group = getSceneScriptManager().getGroupById(groupId);
|
|
|
|
if (group == null || group.monsters == null) {
|
|
return 1;
|
|
}
|
|
|
|
this.getSceneScriptManager()
|
|
.startMonsterTideInGroup(group, ordersConfigId, tideCount, sceneLimit);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int AddExtraGroupSuite(int groupId, int suite) {
|
|
logger.debug("[LUA] Call AddExtraGroupSuite with {},{}", groupId, suite);
|
|
SceneGroup group = getSceneScriptManager().getGroupById(groupId);
|
|
|
|
if (group == null || group.monsters == null) {
|
|
return 1;
|
|
}
|
|
var suiteData = group.getSuiteByIndex(suite);
|
|
if (suiteData == null) {
|
|
return 1;
|
|
}
|
|
// avoid spawn wrong monster
|
|
if (getSceneScriptManager().getScene().getChallenge() != null)
|
|
if (!getSceneScriptManager().getScene().getChallenge().inProgress()
|
|
|| getSceneScriptManager().getScene().getChallenge().getGroup().id != groupId) {
|
|
return 0;
|
|
}
|
|
this.getSceneScriptManager().addGroupSuite(group, suiteData);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int GoToGroupSuite(int groupId, int suite) {
|
|
logger.debug("[LUA] Call GoToGroupSuite with {},{}", groupId, suite);
|
|
SceneGroup group = getSceneScriptManager().getGroupById(groupId);
|
|
if (group == null || group.monsters == null) {
|
|
return 1;
|
|
}
|
|
var suiteData = group.getSuiteByIndex(suite);
|
|
if (suiteData == null) {
|
|
return 1;
|
|
}
|
|
|
|
for (var suiteItem : group.suites) {
|
|
if (suiteData == suiteItem) {
|
|
continue;
|
|
}
|
|
this.getSceneScriptManager().removeGroupSuite(group, suiteItem);
|
|
}
|
|
this.getSceneScriptManager().addGroupSuite(group, suiteData);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int RemoveExtraGroupSuite(int groupId, int suite) {
|
|
logger.debug("[LUA] Call RemoveExtraGroupSuite with {},{}", groupId, suite);
|
|
|
|
SceneGroup group = getSceneScriptManager().getGroupById(groupId);
|
|
if (group == null || group.monsters == null) {
|
|
return 1;
|
|
}
|
|
var suiteData = group.getSuiteByIndex(suite);
|
|
if (suiteData == null) {
|
|
return 1;
|
|
}
|
|
|
|
this.getSceneScriptManager().removeGroupSuite(group, suiteData);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int KillExtraGroupSuite(int groupId, int suite) {
|
|
logger.debug("[LUA] Call KillExtraGroupSuite with {},{}", groupId, suite);
|
|
|
|
SceneGroup group = getSceneScriptManager().getGroupById(groupId);
|
|
if (group == null || group.monsters == null) {
|
|
return 1;
|
|
}
|
|
var suiteData = group.getSuiteByIndex(suite);
|
|
if (suiteData == null) {
|
|
return 1;
|
|
}
|
|
|
|
this.getSceneScriptManager().removeGroupSuite(group, suiteData);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// param3 (probably time limit for timed dungeons)
|
|
public int ActiveChallenge(
|
|
int challengeId,
|
|
int challengeIndex,
|
|
int timeLimitOrGroupId,
|
|
int groupId,
|
|
int objectiveKills,
|
|
int param5) {
|
|
logger.debug(
|
|
"[LUA] Call ActiveChallenge with {},{},{},{},{},{}",
|
|
challengeId,
|
|
challengeIndex,
|
|
timeLimitOrGroupId,
|
|
groupId,
|
|
objectiveKills,
|
|
param5);
|
|
|
|
var challenge =
|
|
ChallengeFactory.getChallenge(
|
|
challengeId,
|
|
challengeIndex,
|
|
timeLimitOrGroupId,
|
|
groupId,
|
|
objectiveKills,
|
|
param5,
|
|
getSceneScriptManager().getScene(),
|
|
getCurrentGroup().get());
|
|
|
|
if (challenge == null) {
|
|
return 1;
|
|
}
|
|
|
|
if (challenge instanceof DungeonChallenge dungeonChallenge) {
|
|
// set if tower first stage (6-1)
|
|
dungeonChallenge.setStage(
|
|
getSceneScriptManager().getVariables().getOrDefault("stage", -1) == 0);
|
|
}
|
|
|
|
getSceneScriptManager().getScene().setChallenge(challenge);
|
|
challenge.start();
|
|
return 0;
|
|
}
|
|
|
|
public int GetGroupMonsterCountByGroupId(int groupId) {
|
|
logger.debug("[LUA] Call GetGroupMonsterCountByGroupId with {}", groupId);
|
|
return (int)
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(e -> e instanceof EntityMonster && e.getGroupId() == groupId)
|
|
.count();
|
|
}
|
|
|
|
public int GetGroupVariableValue(String var) {
|
|
logger.debug("[LUA] Call GetGroupVariableValue with {}", var);
|
|
return getSceneScriptManager().getVariables().getOrDefault(var, 0);
|
|
}
|
|
|
|
public int SetGroupVariableValue(String var, int value) {
|
|
logger.debug("[LUA] Call SetGroupVariableValue with {},{}", var, value);
|
|
getSceneScriptManager().getVariables().put(var, value);
|
|
return 0;
|
|
}
|
|
|
|
public LuaValue ChangeGroupVariableValue(String var, int value) {
|
|
logger.debug("[LUA] Call ChangeGroupVariableValue with {},{}", var, value);
|
|
|
|
getSceneScriptManager()
|
|
.getVariables()
|
|
.put(var, getSceneScriptManager().getVariables().get(var) + value);
|
|
return LuaValue.ZERO;
|
|
}
|
|
|
|
/** Set the actions and triggers to designated group */
|
|
public int RefreshGroup(LuaTable table) {
|
|
logger.debug("[LUA] Call RefreshGroup with {}", printTable(table));
|
|
// Kill and Respawn?
|
|
int groupId = table.get("group_id").toint();
|
|
int suite = table.get("suite").toint();
|
|
|
|
SceneGroup group = getSceneScriptManager().getGroupById(groupId);
|
|
|
|
if (group == null || group.monsters == null) {
|
|
return 1;
|
|
}
|
|
|
|
getSceneScriptManager().refreshGroup(group, suite);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int GetRegionEntityCount(LuaTable table) {
|
|
logger.debug("[LUA] Call GetRegionEntityCount with {}", printTable(table));
|
|
int regionId = table.get("region_eid").toint();
|
|
int entityType = table.get("entity_type").toint();
|
|
|
|
var region = this.getSceneScriptManager().getRegionById(regionId);
|
|
|
|
if (region == null) {
|
|
return 0;
|
|
}
|
|
|
|
return (int) region.getEntities().stream().filter(e -> e >> 24 == entityType).count();
|
|
}
|
|
|
|
public void PrintContextLog(String msg) {
|
|
logger.info("[LUA] " + msg);
|
|
}
|
|
|
|
public int TowerCountTimeStatus(int isDone, int var2) {
|
|
logger.debug("[LUA] Call TowerCountTimeStatus with {},{}", isDone, var2);
|
|
// TODO record time
|
|
return 0;
|
|
}
|
|
|
|
public int GetGroupMonsterCount() {
|
|
logger.debug("[LUA] Call GetGroupMonsterCount ");
|
|
|
|
return (int)
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(
|
|
e ->
|
|
e instanceof EntityMonster
|
|
&& e.getGroupId()
|
|
== getCurrentGroup().map(sceneGroup -> sceneGroup.id).orElse(-1))
|
|
.count();
|
|
}
|
|
|
|
public int SetMonsterBattleByGroup(int var1, int var2, int var3) {
|
|
logger.debug("[LUA] Call SetMonsterBattleByGroup with {},{},{}", var1, var2, var3);
|
|
// TODO
|
|
return 0;
|
|
}
|
|
|
|
public int CauseDungeonFail(int var1) {
|
|
logger.debug("[LUA] Call CauseDungeonFail with {}", var1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int GetGroupVariableValueByGroup(String name, int groupId) {
|
|
logger.debug("[LUA] Call GetGroupVariableValueByGroup with {},{}", name, groupId);
|
|
|
|
return getSceneScriptManager().getVariables().getOrDefault(name, 0);
|
|
}
|
|
|
|
public int SetIsAllowUseSkill(int canUse, int var2) {
|
|
logger.debug("[LUA] Call SetIsAllowUseSkill with {},{}", canUse, var2);
|
|
|
|
getSceneScriptManager().getScene().broadcastPacket(new PacketCanUseSkillNotify(canUse == 1));
|
|
return 0;
|
|
}
|
|
|
|
public int KillEntityByConfigId(LuaTable table) {
|
|
logger.debug("[LUA] Call KillEntityByConfigId with {}", printTable(table));
|
|
var configId = table.get("config_id");
|
|
if (configId == LuaValue.NIL) {
|
|
return 1;
|
|
}
|
|
|
|
var entity = getSceneScriptManager().getScene().getEntityByConfigId(configId.toint());
|
|
if (entity == null) {
|
|
return 0;
|
|
}
|
|
getSceneScriptManager().getScene().killEntity(entity, 0);
|
|
return 0;
|
|
}
|
|
|
|
public int SetGroupVariableValueByGroup(String key, int value, int groupId) {
|
|
logger.debug("[LUA] Call SetGroupVariableValueByGroup with {},{},{}", key, value, groupId);
|
|
|
|
getSceneScriptManager().getVariables().put(key, value);
|
|
return 0;
|
|
}
|
|
|
|
public int CreateMonster(LuaTable table) {
|
|
logger.debug("[LUA] Call CreateMonster with {}", printTable(table));
|
|
var configId = table.get("config_id").toint();
|
|
var delayTime = table.get("delay_time").toint();
|
|
|
|
if (getCurrentGroup().isEmpty()) {
|
|
return 1;
|
|
}
|
|
|
|
getSceneScriptManager().spawnMonstersByConfigId(getCurrentGroup().get(), configId, delayTime);
|
|
return 0;
|
|
}
|
|
|
|
public int TowerMirrorTeamSetUp(int team, int var1) {
|
|
logger.debug("[LUA] Call TowerMirrorTeamSetUp with {},{}", team, var1);
|
|
|
|
getSceneScriptManager().unloadCurrentMonsterTide();
|
|
getSceneScriptManager()
|
|
.getScene()
|
|
.getPlayers()
|
|
.get(0)
|
|
.getTowerManager()
|
|
.mirrorTeamSetUp(team - 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int CreateGadget(LuaTable table) {
|
|
logger.debug("[LUA] Call CreateGadget with {}", printTable(table));
|
|
var configId = table.get("config_id").toint();
|
|
|
|
var group = getCurrentGroup();
|
|
|
|
if (group.isEmpty()) {
|
|
return 1;
|
|
}
|
|
|
|
var gadget = group.get().gadgets.get(configId);
|
|
var entity = getSceneScriptManager().createGadget(group.get().id, group.get().block_id, gadget);
|
|
|
|
getSceneScriptManager().addEntity(entity);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int CheckRemainGadgetCountByGroupId(LuaTable table) {
|
|
logger.debug("[LUA] Call CheckRemainGadgetCountByGroupId with {}", printTable(table));
|
|
var groupId = table.get("group_id").toint();
|
|
|
|
var count =
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(
|
|
g -> g instanceof EntityGadget entityGadget && entityGadget.getGroupId() == groupId)
|
|
.count();
|
|
return (int) count;
|
|
}
|
|
|
|
public int GetGadgetStateByConfigId(int groupId, int configId) {
|
|
logger.debug("[LUA] Call GetGadgetStateByConfigId with {},{}", groupId, configId);
|
|
|
|
if (groupId == 0) {
|
|
groupId = getCurrentGroup().get().id;
|
|
}
|
|
final int realGroupId = groupId;
|
|
var gadget =
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(
|
|
g ->
|
|
g instanceof EntityGadget entityGadget
|
|
&& entityGadget.getGroupId() == realGroupId)
|
|
.filter(g -> g.getConfigId() == configId)
|
|
.findFirst();
|
|
if (gadget.isEmpty()) {
|
|
return 1;
|
|
}
|
|
return ((EntityGadget) gadget.get()).getState();
|
|
}
|
|
|
|
public int MarkPlayerAction(int var1, int var2, int var3, int var4) {
|
|
logger.debug("[LUA] Call MarkPlayerAction with {},{},{},{}", var1, var2, var3, var4);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int AddQuestProgress(String var1) {
|
|
logger.debug("[LUA] Call AddQuestProgress with {}", var1);
|
|
|
|
for (var player : getSceneScriptManager().getScene().getPlayers()) {
|
|
player.getQuestManager().triggerEvent(QuestTrigger.QUEST_COND_LUA_NOTIFY, var1);
|
|
player.getQuestManager().triggerEvent(QuestContent.QUEST_CONTENT_LUA_NOTIFY, var1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** change the state of gadget */
|
|
public int ChangeGroupGadget(LuaTable table) {
|
|
logger.debug("[LUA] Call ChangeGroupGadget with {}", printTable(table));
|
|
var configId = table.get("config_id").toint();
|
|
var state = table.get("state").toint();
|
|
|
|
var entity = getSceneScriptManager().getScene().getEntityByConfigId(configId);
|
|
if (entity == null) {
|
|
return 1;
|
|
}
|
|
|
|
if (entity instanceof EntityGadget entityGadget) {
|
|
entityGadget.updateState(state);
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
public int GetEntityType(int entityId) {
|
|
var entity = getSceneScriptManager().getScene().getEntityById(entityId);
|
|
if (entity == null) {
|
|
// check players
|
|
Player player = DatabaseHelper.getPlayerByUid(entityId);
|
|
if (player != null) {
|
|
return EntityType.Avatar.getValue();
|
|
}
|
|
|
|
return EntityType.None.getValue();
|
|
}
|
|
|
|
return entity.getEntityType();
|
|
}
|
|
|
|
public int GetQuestState(int entityId, int questId) {
|
|
var player = getSceneScriptManager().getScene().getWorld().getHost();
|
|
|
|
var quest = player.getQuestManager().getQuestById(questId);
|
|
if (quest == null) {
|
|
return QuestState.QUEST_STATE_NONE.getValue();
|
|
}
|
|
|
|
return quest.getState().getValue();
|
|
}
|
|
|
|
public int ShowReminder(int reminderId) {
|
|
getSceneScriptManager()
|
|
.getScene()
|
|
.broadcastPacket(new PacketDungeonShowReminderNotify(reminderId));
|
|
return 0;
|
|
}
|
|
|
|
public int RemoveEntityByConfigId(int groupId, int entityType, int configId) {
|
|
logger.debug("[LUA] Call RemoveEntityByConfigId");
|
|
|
|
var entity =
|
|
getSceneScriptManager().getScene().getEntities().values().stream()
|
|
.filter(e -> e.getGroupId() == groupId)
|
|
.filter(e -> e.getEntityType() == entityType)
|
|
.filter(e -> e.getConfigId() == configId)
|
|
.findFirst();
|
|
|
|
if (entity.isEmpty()) {
|
|
return 1;
|
|
}
|
|
|
|
getSceneScriptManager().getScene().removeEntity(entity.get());
|
|
|
|
return 0;
|
|
}
|
|
}
|