/// <summary>
/// Teleports into an instance
/// </summary>
/// <param name="chr"></param>
/// <param name="trigger"></param>
/// <returns></returns>
public static bool HandleTeleport(Character chr, AreaTrigger trigger)
{
var mapInfo = World.GetMapTemplate(trigger.Template.TargetMap);
#if DEBUG
chr.SendSystemMessage("Target location: {0}", trigger.Template.TargetMap);
#endif
if (mapInfo.IsInstance)
{
if (mapInfo.Type == MapType.Normal)
{
InstanceMgr.LeaveInstance(chr, mapInfo, trigger.Template.TargetPos);
return(true);
}
else
{
return(InstanceMgr.EnterInstance(chr, mapInfo, trigger.Template.TargetPos));
}
}
else if (mapInfo.BattlegroundTemplate == null)
{
var rgn = World.GetNonInstancedMap(mapInfo.Id);
if (rgn != null)
{
chr.TeleportTo(rgn, trigger.Template.TargetPos, trigger.Template.TargetOrientation);
return(true);
}
else
{
ContentMgr.OnInvalidDBData("Invalid Map: " + rgn);
}
}
return(true);
}
/// <summary>Teleports into an instance</summary>
/// <param name="chr"></param>
/// <param name="trigger"></param>
/// <returns></returns>
public static bool HandleTeleport(Character chr, AreaTrigger trigger)
{
MapTemplate mapTemplate = World.GetMapTemplate(trigger.Template.TargetMap);
if (mapTemplate.IsInstance)
{
if (mapTemplate.Type != MapType.Normal)
{
return(InstanceMgr.EnterInstance(chr, mapTemplate, trigger.Template.TargetPos));
}
InstanceMgr.LeaveInstance(chr, mapTemplate, trigger.Template.TargetPos);
return(true);
}
if (mapTemplate.BattlegroundTemplate == null)
{
Map nonInstancedMap = World.GetNonInstancedMap(mapTemplate.Id);
if (nonInstancedMap != null)
{
chr.TeleportTo(nonInstancedMap, trigger.Template.TargetPos,
new float?(trigger.Template.TargetOrientation));
return(true);
}
ContentMgr.OnInvalidDBData("Invalid Map: " + (object)nonInstancedMap);
}
else
{
chr.AddMessage((Action)(() => chr.TeleportTo(trigger.Template.TargetMap, trigger.Template.TargetPos)));
}
return(true);
}
public static void WriteInstanceStubs()
{
var dir = ToolConfig.DefaultAddonSourceDir + "Instances/";
RealmDBMgr.Initialize();
ContentMgr.Initialize();
World.InitializeWorld();
InstanceMgr.Initialize();
foreach (var instance in InstanceMgr.InstanceInfos)
{
var className = instance.Id.ToString();
var baseClass = typeof(BaseInstance).Name;
var file = dir + className + ".cs";
if (!File.Exists(file))
{
using (var writer = new CodeFileWriter(file, "WCell.Addons.Default.Instances",
className,
"class",
": " + baseClass,
"WCell.RealmServer.Instances"))
{
}
}
}
}
} // end CheckAttributeData
public override void UnderAttack(IDamageData damage) {
if (null == damage) return;
// end if
IRealData realData = new RealData(damage, m_charcterData);
m_charcterData.Minus(realData);
Vector2 screenPoint = SceneManager.mainCamera.camera.WorldToScreenPoint(character.helpTransform.position);
Vector2 hud_pos;
if (RectTransformUtility.ScreenPointToLocalPointInRectangle(SceneManager.mainCanvas.HUD_rectTRansform, screenPoint,
SceneManager.mainCanvas.camera, out hud_pos)) {
HUD_Damage hud = InstanceMgr.GetObjectManager().GetGameObject<HUD_Damage>(HUD_Damage.poolName);
hud.SetNumber(realData.HP);
hud.transform.SetParent(SceneManager.mainCanvas.HUD_rectTRansform, false);
hud.transform.localPosition = hud_pos;
hud.gameObject.SetActive(true);
} // end if
if (null != lockCharacter) return;
// end if
if (damage.hashID == SceneManager.mainCharacter.hashID) {
LockCharacter(SceneManager.mainCharacter);
return;
} // end if
ICharacter npc = SceneManager.characterManager.factory.GetNPCharacter(damage.hashID);
if (null != npc) {
LockCharacter(npc);
} // end if
} // end UnderAttack
static bool DeleteCharAccessories(uint charId)
{
try
{
SpellRecord.DeleteAll("OwnerId = " + charId);
AuraRecord.DeleteAll("OwnerId = " + charId);
ItemRecord.DeleteAll("OwnerId = " + charId);
SkillRecord.DeleteAll("OwnerId = " + charId);
SpecProfile.DeleteAll("CharacterId = " + charId);
ReputationRecord.DeleteAll("OwnerId = " + charId);
QuestRecord.DeleteAll("OwnerId = " + charId);
SummonedPetRecord.DeleteAll("OwnerLowId = " + charId);
PermanentPetRecord.DeleteAll("OwnerLowId = " + charId);
MailMgr.ReturnValueMailFor(charId);
MailMessage.DeleteAll("ReceiverId = " + charId);
RelationMgr.Instance.RemoveRelations(charId);
InstanceMgr.RemoveLog(charId);
GroupMgr.Instance.RemoveOfflineCharacter(charId);
AchievementRecord.DeleteAll("CharacterId = " + charId);
AchievementProgressRecord.DeleteAll("CharacterId = " + charId);
return(true);
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to delete character with Id: " + charId);
return(false);
}
}
} // end Update
public void Recycling() {
damage = null;
foreach (TrailRenderer trail in GetComponentsInChildren<TrailRenderer>()) {
trail.Clear();
} // end foreach
InstanceMgr.GetObjectManager().Recycling(poolName, gameObject);
} // end Recycling
} // end DoBeforeEntering
public void Reason()
{
if (false == mainCharacter.avatar.isPlaying)
{
if (isCarom)
{
mainCharacter.fsm.PerformTransition(caromState);
}
else
{
mainCharacter.fsm.PerformTransition("wait");
} // end if
return;
} // end if
if (isFinish)
{
return;
}
// end if
AnimationState state = mainCharacter.avatar.GetCurrentState(anim);
if (state.normalizedTime < 0.5f)
{
return;
}
// end if
isFinish = true;
DamageData damage = new DamageData(mainCharacter);
Arrow arrow = InstanceMgr.GetObjectManager().GetGameObject <Arrow>(Arrow.poolName);
arrow.transform.position = mainCharacter.position + Vector3.up * 0.8f;
arrow.transform.rotation = mainCharacter.rotation;
arrow.SetDamage(damage);
arrow.gameObject.SetActive(true);
} // end Reason
private void Awake()
{
if (mInstance == null)
{
mInstance = this;
}
}
} // end Reason
public void Act()
{
if (skillStep != SkillStep.Step2)
{
return;
}
// end if
AnimationState state = character.avatar.GetCurrentState("skill3_2");
if (null == state)
{
return;
}
// end if
int index = (int)state.normalizedTime;
if (index < 0 || index >= signArr.Length)
{
return;
}
// end if
if (true == signArr[index])
{
return;
}
// end if
signArr[index] = true;
DamageData damage = new DamageData(character);
Arrow arrow = InstanceMgr.GetObjectManager().GetGameObject <Arrow>(Arrow.poolName);
arrow.transform.position = character.position + Vector3.up * 0.8f;
arrow.transform.rotation = character.rotation;
arrow.SetDamage(damage);
arrow.gameObject.SetActive(true);
} // end Act
} // end ObjectTimer
public bool IsOverTime(float deltaTime) {
time -= deltaTime;
if (time > 0) return false;
// end if
InstanceMgr.GetObjectManager().Recycling(name, Go);
Go = null;
return true;
} // end IsOverTime
private IEnumerator Start() {
InstanceMgr.Init();
SqliteManager.Init();
Application.targetFrameRate = 30;
Resources.Load<ShaderVariantCollection>("Shader/ShaderVariants").WarmUp();
yield return null;
LoaderScene.LoadNextLevel(new LoginScene());
} // end Start
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
var chr = trigger.Args.Target as Character;
var mod = trigger.Text.NextModifiers();
var mapid = trigger.Text.NextEnum(MapId.End);
if (mapid == MapId.End)
{
trigger.Reply("Invalid MapId.");
return;
}
var mapTemplate = World.GetMapTemplate(mapid);
if (mapTemplate != null && mapTemplate.IsInstance)
{
uint diffIndex;
if (mod.Contains("d"))
{
diffIndex = trigger.Text.NextUInt();
var diff = mapTemplate.GetDifficulty(diffIndex);
if (diff == null)
{
trigger.Reply("Invalid Difficulty: {0}");
}
}
else if (chr != null)
{
diffIndex = chr.GetInstanceDifficulty(mapTemplate.IsRaid);
}
else
{
diffIndex = 0;
}
var instance = InstanceMgr.CreateInstance(chr, mapTemplate.InstanceTemplate, diffIndex);
if (instance != null)
{
trigger.Reply("Instance created: " + instance);
if (mod.Contains("e"))
{
if (chr != null)
{
instance.TeleportInside((Character)trigger.Args.Target);
}
}
}
else
{
trigger.Reply("Unable to create Instance of: " + mapTemplate);
}
}
else
{
trigger.Reply("Invalid MapId.");
}
}
//public static void ShowEffectOnce(string name, Vector3 posistion) {
// ObjectTool.InstantiateGo(name, ResourcesTool.LoadPrefab(name), null, posistion, Vector3.zero, Vector3.one);
//} // end ShowEffectOnce
public static void ShowEffectFromPool(string name, float time, Vector3 posistion)
{
GameObject Go = InstanceMgr.GetObjectManager().GetGameObject(name, time);
if (null == Go)
{
return;
}
// end if
Go.transform.position = posistion;
Go.SetActive(true);
} // end ShowEffectCache
} // end OnClickAttack
private bool Flight() {
if (isFlight) return false;
// end if
isFlight = true;
mainCharacter.avatar.Play("attack2_2");
DamageData damage = new DamageData(mainCharacter);
Magic_0 arrow = InstanceMgr.GetObjectManager().GetGameObject<Magic_0>(Magic_0.poolName);
arrow.transform.position = mainCharacter.position + Vector3.up * 0.8f;
arrow.transform.rotation = mainCharacter.rotation;
arrow.SetDamage(damage);
arrow.gameObject.SetActive(true);
return true;
} // end Flight
public override void Process(CmdTrigger <RealmServerCmdArgs> trigger)
{
Character target = trigger.Args.Target as Character;
string str = trigger.Text.NextModifiers();
MapId mapID = trigger.Text.NextEnum(MapId.End);
if (mapID == MapId.End)
{
trigger.Reply("Invalid MapId.");
}
else
{
MapTemplate mapTemplate = World.GetMapTemplate(mapID);
if (mapTemplate != null && mapTemplate.IsInstance)
{
uint num;
if (str.Contains("d"))
{
num = trigger.Text.NextUInt();
if (mapTemplate.GetDifficulty(num) == null)
{
trigger.Reply("Invalid Difficulty: {0}");
}
}
else
{
num = target == null ? 0U : target.GetInstanceDifficulty(mapTemplate.IsRaid);
}
BaseInstance instance = InstanceMgr.CreateInstance(target, mapTemplate.InstanceTemplate, num);
if (instance != null)
{
trigger.Reply("Instance created: " + instance);
if (!str.Contains("e") || target == null)
{
return;
}
instance.TeleportInside((Character)trigger.Args.Target);
}
else
{
trigger.Reply("Unable to create Instance of: " + mapTemplate);
}
}
else
{
trigger.Reply("Invalid MapId.");
}
}
}
} // end UnderAttack
public override void SwitchHpBar(bool isShow) {
if (isShow) {
if (null == hpBar) {
hpBar = InstanceMgr.GetObjectManager().GetGameObject<HP_Bar>(HP_Bar.poolName);
hpBar.transform.SetParent(character.helpTransform, false);
hpBar.gameObject.SetActive(true);
} // end if
} else {
if (null == hpBar) return;
// end if
hpBar.Recycling();
hpBar = null;
} // end if
} // end SwitchHpBar
public static InstanceMgr GetInstance()
{
if (mInstance == null)
{
GameObject mgr = GameObject.Find("InstanceMgr");
if (mgr == null)
{
return(null);
}
mInstance = mgr.GetComponent <InstanceMgr>();
}
return(mInstance);
}
private static bool DeleteCharAccessories(uint charId)
{
try
{
ActiveRecordBase <SpellRecord> .DeleteAll("OwnerId = " + (object)charId);
ActiveRecordBase <AuraRecord> .DeleteAll("OwnerId = " + (object)charId);
ActiveRecordBase <ItemRecord> .DeleteAll("OwnerId = " + (object)charId);
ActiveRecordBase <SkillRecord> .DeleteAll("OwnerId = " + (object)charId);
ActiveRecordBase <SpecProfile> .DeleteAll("CharacterId = " + (object)charId);
ActiveRecordBase <ReputationRecord> .DeleteAll("OwnerId = " + (object)charId);
ActiveRecordBase <QuestRecord> .DeleteAll("OwnerId = " + (object)charId);
ActiveRecordBase <SummonedPetRecord> .DeleteAll("OwnerLowId = " + (object)charId);
ActiveRecordBase <PermanentPetRecord> .DeleteAll("OwnerLowId = " + (object)charId);
MailMgr.ReturnValueMailFor(charId);
ActiveRecordBase <MailMessage> .DeleteAll("ReceiverId = " + (object)charId);
Singleton <RelationMgr> .Instance.RemoveRelations(charId);
InstanceMgr.RemoveLog(charId);
Singleton <GroupMgr> .Instance.RemoveOfflineCharacter(charId);
ActiveRecordBase <AchievementRecord> .DeleteAll("CharacterId = " + (object)charId);
ActiveRecordBase <AchievementProgressRecord> .DeleteAll("CharacterId = " + (object)charId);
return(true);
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to delete character with Id: " + (object)charId, new object[0]);
return(false);
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
GUILayout.Space(30f);
InstanceMgr targetMgr = target as InstanceMgr;
GUILayout.Space(10f);
if (GUILayout.Button("Collect As Data"))
{
// 把东西给收集起来
Debug.Log(target.name);
targetMgr.Collect();
}
GUILayout.Space(10f);
if (GUILayout.Button("PreviewData"))
{
// 预览
}
}
} // end DoBeforeEntering
public void Reason() {
if (false == character.info.characterData.IsLive) {
character.fsm.PerformTransition(NPCStateID.Die);
return;
} // end if
if (false == character.avatar.isPlaying) {
if (null == character.info.lockCharacter) {
character.fsm.PerformTransition(NPCStateID.Idle);
return;
} //end if
if (Vector3.Distance(character.info.lockCharacter.position, character.position) < reach) {
character.fsm.PerformTransition(id);
return;
} // end if
character.fsm.PerformTransition(NPCStateID.Chase);
return;
} // end if
if (isFlight) return;
// end if
if (null == character.info.lockCharacter) {
character.fsm.PerformTransition(NPCStateID.Idle);
return;
} //end if
character.move.LookAt(character.info.lockCharacter.position);
AnimationState state = character.avatar.GetCurrentState(anim);
if (null == state || state.normalizedTime < 0.5f) return;
// end if
isFlight = true;
if (Vector3.Distance(character.info.lockCharacter.position, character.position) > reach) return;
// end if
DamageData damage = new DamageData(character);
NPC_Arrow arrow = InstanceMgr.GetObjectManager().GetGameObject<NPC_Arrow>(effectPath);
arrow.transform.position = character.position + Vector3.up * 0.5f;
arrow.transform.rotation = character.rotation;
arrow.SetDamage(effectPath, damage);
arrow.gameObject.SetActive(true);
} // end Reason
public static NPCSpawnEntry GetNPCSpawnEntry(CmdTrigger <RealmServerCmdArgs> trigger, bool closest, out Map map)
{
Unit target = trigger.Args.Target;
map = null;
NPCSpawnEntry npcSpawnEntry;
if (closest)
{
if (target == null)
{
trigger.Reply("Cannot use the -c switch without active Target.");
return(null);
}
npcSpawnEntry = NPCMgr.GetClosestSpawnEntry(target);
if (npcSpawnEntry == null)
{
trigger.Reply("No Spawnpoint found.");
return(null);
}
}
else
{
string str = trigger.Text.NextWord();
NPCId result1;
if (!EnumUtil.TryParse(str, out result1))
{
uint result2;
uint.TryParse(str, out result2);
npcSpawnEntry = NPCMgr.GetSpawnEntry(result2);
if (npcSpawnEntry == null)
{
trigger.Reply("Invalid SpawnId: " + result2);
return(null);
}
}
else
{
NPCEntry entry = NPCMgr.GetEntry(result1);
if (entry == null)
{
trigger.Reply("Entry not found: " + result1);
return(null);
}
if (entry.SpawnEntries.Count == 0)
{
trigger.Reply("Entry has no SpawnEntries: " + entry);
return(null);
}
npcSpawnEntry = target != null
? entry.SpawnEntries.GetClosestSpawnEntry(target)
: entry.SpawnEntries.First();
}
}
map = npcSpawnEntry.Map;
if (map == null)
{
if (target != null && npcSpawnEntry.MapId == target.MapId)
{
map = target.Map;
}
else if (World.IsInstance(npcSpawnEntry.MapId))
{
map = InstanceMgr.CreateInstance(target as Character, npcSpawnEntry.MapId);
if (map == null)
{
trigger.Reply("Failed to create instance: " + npcSpawnEntry.MapId);
return(null);
}
}
else
{
trigger.Reply("Cannot spawn NPC for map: " + npcSpawnEntry.MapId);
return(null);
}
}
return(npcSpawnEntry);
}
} // end SetSceneName
private void Start() {
GameManager.SetGameState(GameState.INITIALIZATION);
InstanceMgr.Init();
m_scene.Initialize();
GameManager.SetGameState(GameState.PLAY);
} // end Start
} // end Start
private void Update() {
m_scene.Update();
if (GameManager.state == GameState.PLAY)
InstanceMgr.Update();
// end if
} // end Update
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
{
base.Configure(cmd, cameraTextureDescriptor);
instanceData = InstanceMgr.GetInstance();
}
internal void DoFinishLogout()
{
if (!m_isLoggingOut)
{
// cancel if logout was cancelled
return;
}
var evt = LoggingOut;
if (evt != null)
{
evt(this);
}
// take Player out of world context
if (!World.RemoveCharacter(this))
{
// was already removed
return;
}
// client might now do other things
m_client.ActiveCharacter = null;
Account.ActiveCharacter = null;
// set to false so it can't be cancelled anymore
m_isLoggingOut = false;
// get rid of any minions, totems and their summons
RemoveSummonedEntourage();
// jump out of vehicle
DetatchFromVechicle();
// remove from the channels they're in
for (var i = ChatChannels.Count - 1; i >= 0; i--)
{
ChatChannels[i].Leave(this, true);
}
if (Ticket != null)
{
Ticket.OnOwnerLogout();
Ticket = null;
}
if (m_TaxiMovementTimer != null)
{
m_TaxiMovementTimer.Stop();
}
GroupMgr.Instance.OnCharacterLogout(m_groupMember);
GuildMgr.Instance.OnCharacterLogout(m_guildMember);
RelationMgr.Instance.OnCharacterLogout(this);
InstanceMgr.OnCharacterLogout(this);
Battlegrounds.OnLogout();
LastLogout = DateTime.Now;
// delete and re-spawn corpses and pets when logging back in
if (m_corpse != null)
{
m_corpse.Delete();
}
CancelAllActions();
m_auras.CleanupAuras();
m_Map.RemoveObjectNow(this);
//if (!IsPlayerLogout)
if (!Account.IsActive)
{
// Character has been banned
m_client.Disconnect();
}
else
{
CharacterHandler.SendPlayerImmediateLogoutReply(m_client);
}
if (CharacterHandler.NotifyPlayerStatus)
{
World.Broadcast("{0} is now " + ChatUtility.Colorize("Offline", Color.Red) + ".", Name);
}
m_initialized = false;
Dispose();
}
} // end SetFillAmount
public void Recycling() {
InstanceMgr.GetObjectManager().Recycling(poolName, gameObject);
} // end Recycling
/// <summary>
/// Loads and adds the Character to its Map.
/// </summary>
/// <remarks>Called initially from the IO-Context</remarks>
internal void LoadAndLogin()
{
// set Zone *before* Map
// TODO: Also retrieve Battlegrounds
m_Map = World.GetMap(m_record);
InstanceMgr.RetrieveInstances(this);
AreaCharCount++; // Characters are always in active regions
if (!Role.IsStaff)
{
Stunned++;
}
var isStaff = Role.IsStaff;
if (m_Map == null && (!isStaff || (m_Map = InstanceMgr.CreateInstance(this, m_record.MapId)) == null))
{
// map does not exist anymore
Load();
TeleportToBindLocation();
AddMessage(InitializeCharacter);
return;
}
else
{
Load();
if (m_Map.IsDisposed ||
(m_Map.IsInstance && !isStaff && (m_Map.CreationTime > m_record.LastLogout || !m_Map.CanEnter(this))))
{
// invalid Map or not allowed back in (might be an Instance)
m_Map.TeleportOutside(this);
AddMessage(InitializeCharacter);
}
else
{
m_Map.AddMessage(() =>
{
// add to map
if (m_Map is Battleground)
{
var bg = (Battleground)m_Map;
if (!bg.LogBackIn(this))
{
// teleport out of BG
AddMessage(InitializeCharacter);
return;
}
}
m_position = new Vector3(m_record.PositionX,
m_record.PositionY,
m_record.PositionZ);
m_zone = m_Map.GetZone(m_record.Zone);
if (m_zone != null && m_record.JustCreated)
{
// set initial zone explored automatically
SetZoneExplored(m_zone.Id, false);
}
// during the next Map-wide Character-update, the Character is going to be added to the map
// and created/initialized immediately afterwards
m_Map.AddObjectNow(this);
InitializeCharacter();
});
}
}
}
public static NPCSpawnEntry GetNPCSpawnEntry(CmdTrigger <RealmServerCmdArgs> trigger, bool closest, out Map map)
{
var target = trigger.Args.Target;
NPCSpawnEntry entry;
map = null;
if (closest)
{
if (target == null)
{
trigger.Reply("Cannot use the -c switch without active Target.");
return(null);
}
entry = NPCMgr.GetClosestSpawnEntry(target);
if (entry == null)
{
trigger.Reply("No Spawnpoint found.");
return(null);
}
}
else
{
var word = trigger.Text.NextWord();
NPCId npcId;
if (!EnumUtil.TryParse(word, out npcId))
{
uint spawnId;
uint.TryParse(word, out spawnId);
entry = NPCMgr.GetSpawnEntry(spawnId);
if (entry == null)
{
trigger.Reply("Invalid SpawnId: " + spawnId);
return(null);
}
}
else
{
var npcEntry = NPCMgr.GetEntry(npcId);
if (npcEntry == null)
{
trigger.Reply("Entry not found: " + npcId);
return(null);
}
if (npcEntry.SpawnEntries.Count == 0)
{
trigger.Reply("Entry has no SpawnEntries: " + npcEntry);
return(null);
}
entry = target != null?npcEntry.SpawnEntries.GetClosestSpawnEntry(target) : npcEntry.SpawnEntries.First();
}
}
// found entry - now determine Map
map = entry.Map;
if (map == null)
{
if (target != null && entry.MapId == target.MapId)
{
// is in same map
map = target.Map;
}
else
{
// must create Map
if (World.IsInstance(entry.MapId))
{
// create instance
map = InstanceMgr.CreateInstance(target as Character, entry.MapId);
if (map == null)
{
trigger.Reply("Failed to create instance: " + entry.MapId);
return(null);
}
}
else
{
trigger.Reply("Cannot spawn NPC for map: " + entry.MapId);
return(null);
}
}
}
return(entry);
}
void InitInstance()
{
_instanceManager = new InstanceMgr();
_instanceManager.InitInstance();
_instanceManager.RunInstance();
}
