/// <summary>
/// 触发器结束
/// </summary>
/// <param name="trigger"></param>
private void OnTriggerDead(TriggerBase trigger)
{
if (onTriggerFinish != null)
{
onTriggerFinish(trigger);
}
}
public static void DisplayCommandDescription(TriggerBase trigger, CommandBase command)
{
trigger.Reply(trigger.Bold("{0}") + "{1} - {2}", new object[]
{
string.Join("/", command.Aliases),
(command is SubCommandContainer) ? string.Format(" ({0} subcmds)", (command as SubCommandContainer).Count((SubCommand entry) => entry.RequiredRole <= trigger.UserRole)) : "",
command.Description
});
}
void OnEntityEnter(TriggerBase trigger, BaseEntity entity)
{
if (!(entity is BasePlayer) || !(trigger is BuildPrivilegeTrigger))
{
return;
}
timer.Once(RaidTimer, () => Raidable[entity]);
}
public Character GetTarget(TriggerBase trigger)
{
Character[] targets = this.GetTargets(trigger);
if (targets.Length > 1)
{
throw new System.Exception("Only 1 target allowed");
}
return(targets[0]);
}
protected override void Awake()
{
base.Awake();
_helper.Init();
_trigger = GetComponent <TriggerBase>();
Assert.IsNotNull(_trigger, "No TriggerBase found on object.");
}
public static void DisplaySubCommandDescription(TriggerBase trigger, CommandBase command, SubCommand subcommand)
{
trigger.Reply(trigger.Bold("{0}") + " {1} - {2}", new object[]
{
command.Aliases.First <string>(),
string.Join("/", subcommand.Aliases),
subcommand.Description
});
}
public override void Execute(TriggerBase trigger)
{
IEnumerable <MonsterSpawn> spawns;
var monster = trigger.Get <MonsterTemplate>("monster");
if (trigger.IsArgumentDefined("subarea"))
{
var subArea = trigger.Get <SubArea>("subarea");
spawns = subArea.Maps.SelectMany(x => x.MonsterSpawns).Distinct().Where(x => x.MonsterId == monster.Id);
}
else
{
spawns = MonsterManager.Instance.GetMonsterSpawns().Where(x => x.MonsterId == monster.Id);
}
foreach (var spawn in spawns)
{
if (spawn.Map != null)
{
spawn.Map.AddMonsterSpawn(spawn);
}
if (spawn.SubArea == null)
{
continue;
}
foreach (var map in spawn.SubArea.Maps)
{
map.AddMonsterSpawn(spawn);
}
}
WorldServer.Instance.IOTaskPool.AddMessage(
() =>
{
WorldServer.Instance.DBAccessor.Database.BeginTransaction();
var count = 0;
foreach (var spawn in spawns)
{
if (spawn.IsDisabled)
{
count++;
}
spawn.IsDisabled = false;
WorldServer.Instance.DBAccessor.Database.Update(spawn);
}
WorldServer.Instance.DBAccessor.Database.CompleteTransaction();
trigger.ReplyBold("Re-Enabled {0} spawns", count);
});
}
public override void Execute(TriggerBase trigger)
{
var transition = trigger.Get <MapNeighbour>("t");
var map = trigger.Get <Map>("map");
var cell = trigger.IsArgumentDefined("cell") ? map.GetCell(trigger.Get <short>("cell")) : null;
Map from;
if (trigger.IsArgumentDefined("from"))
{
from = trigger.Get <Map>("from");
}
else
{
if (!(trigger is GameTrigger))
{
trigger.ReplyError("From not defined");
return;
}
from = (trigger as GameTrigger).Character.Map;
}
switch (transition)
{
case MapNeighbour.Top:
from.TopNeighbour = map;
from.Record.TopNeighbourCellId = cell?.Id;
break;
case MapNeighbour.Bottom:
from.BottomNeighbour = map;
from.Record.BottomNeighbourCellId = cell?.Id;
break;
case MapNeighbour.Right:
from.RightNeighbour = map;
from.Record.RightNeighbourCellId = cell?.Id;
break;
case MapNeighbour.Left:
from.LeftNeighbour = map;
from.Record.LeftNeighbourCellId = cell?.Id;
break;
default:
trigger.ReplyError("{0} not a valid transition", transition);
return;
}
WorldServer.Instance.IOTaskPool.ExecuteInContext(() =>
{
WorldServer.Instance.DBAccessor.Database.Update(from.Record);
trigger.ReplyBold("{0} -> {1} = {2}", from.Id, transition, map.Id);
});
}
public override void Execute(TriggerBase trigger)
{
Map map = ((GameTrigger)trigger).Character.Map;
string arg = map.ToggleMute() ? "La map est maintenant réduite au silence !" : "La map n'est plus réduite au silence !";
BasicHandler.SendTextInformationMessage(map.Clients, TextInformationTypeEnum.TEXT_INFORMATION_MESSAGE, 0, new string[]
{
string.Format("<font color=\"#{0}\">{1}</font>", Color.Red.ToArgb().ToString("X"), arg)
});
}
public override void Execute(TriggerBase trigger)
{
int i = 0;
int count = trigger.Get <int>("times");
PingIO(trigger, 0, trigger.Get <int>("times"), new List <DateTime>()
{
DateTime.Now
});
}
public override void Execute(TriggerBase trigger)
{
foreach (var target in GetTargets(trigger))
{
target.Stats.Health.DamageTaken = 0;
target.Energy = target.EnergyMax;
target.RefreshStats();
}
}
public override void Execute(TriggerBase trigger)
{
Character[] targets = base.GetTargets(trigger);
for (int i = 0; i < targets.Length; i++)
{
Character character = targets[i];
character.ToggleGodMode(false);
trigger.Reply("You're not god anymore");
}
}
public override void Execute(TriggerBase trigger)
{
foreach (var target in GetTargets(trigger))
{
var amount = trigger.Get <int>("amount");
target.Inventory.AddKamas(amount);
trigger.ReplyBold($"{amount} Kamas was added to {target} and he now have {target.Kamas} kamas");
}
}
public override void Execute(TriggerBase trigger)
{
if (!(trigger is GameTrigger))
{
trigger.ReplyError("This command can only be executed in game");
return;
}
Execute(trigger as GameTrigger);
}
public void Mirror(TriggerBase source)
{
this.colliderStyle = source.colliderStyle;
this.center = source.center;
this.boxSize = source.boxSize;
this.radius = source.radius;
this.mesh = source.mesh;
this.lineWidth = source.lineWidth;
this.isDraw = source.isDraw;
}
public override void SaveTrigger(TriggerBase trigger)
{
var prevTrigger = _triggers.FirstOrDefault(x => x.Id.Equals(trigger.Id));
_dataManager.Set(trigger.Id, trigger);
var index = _triggers.IndexOf(_triggers.FirstOrDefault(x => x.Id.Equals(trigger.Id)));
_triggers.RemoveAll(x => x.Id.Equals(trigger.Id));
_triggers.Insert(index, trigger);
}
public override void Execute(TriggerBase trigger)
{
var target = GetTarget(trigger);
foreach (var spell in target.Spells)
{
trigger.Reply("{0} ({1}) - Level {2}", trigger.Bold(spell.Template.Name), trigger.Bold(spell.Id),
trigger.Bold(spell.CurrentLevel));
}
}
private static void PrintBufferInformations(TriggerBase trigger, BufferManager manager, string name)
{
trigger.Reply("- {0} ({1}):", name, manager.SegmentSize);
trigger.Reply("\tInUse : " + manager.InUse);
trigger.Reply("\tTotalAllocatedMemory : " + manager.TotalAllocatedMemory.ToString(new FileSizeFormatProvider()));
trigger.Reply("\tAvailableSegmentsCount : " + manager.AvailableSegmentsCount);
trigger.Reply("\tUsedSegmentCount : " + manager.UsedSegmentCount);
trigger.Reply("\tTotalSegmentCount : " + manager.TotalSegmentCount);
trigger.Reply("");
}
public void ChangeTriggerRadius(TriggerBase trigger, float newRadius)
{
if (newRadius < 0f)
{
throw new InvalidOperationException(String.Format("Radius can't be less then zero. ChangeTriggerRadius({0}, {1})", trigger, newRadius));
}
trigger.GetComponent <SphereCollider>().radius = newRadius;
trigger.SendMessage("OnValidate", SendMessageOptions.DontRequireReceiver);
}
private static void OnReply(TriggerBase trigger, AccountAnswerMessage reply)
{
trigger.Reply("Account : {0} ({1})", trigger.Bold(reply.Account.Login),
trigger.Bold(reply.Account.Id));
trigger.Reply("Banned : {0}", trigger.Bold(reply.Account.IsBanned));
trigger.Reply("Jailed : {0}", trigger.Bold(reply.Account.IsJailed));
trigger.Reply("Reason : {0}", trigger.Bold(reply.Account.BanReason));
trigger.Reply("Until : {0}", trigger.Bold(reply.Account.BanEndDate));
}
public override void Execute(TriggerBase trigger)
{
if (!IPCAccessor.Instance.IsConnected)
{
trigger.ReplyError("IPC service not operational !");
return;
}
var player = World.Instance.GetCharacter(trigger.Get <string>("player"));
if (player == null)
{
WorldServer.Instance.IOTaskPool.ExecuteInContext(() =>
{
var character =
CharacterManager.Instance.GetCharacterByName(trigger.Get <string>("player"));
if (character == null)
{
trigger.ReplyError("Player {0} not found", trigger.Get <string>("player"));
return;
}
var message = new AccountRequestMessage {
CharacterId = character.Id
};
IPCAccessor.Instance.SendRequest <AccountAnswerMessage>(message,
reply => IPCAccessor.Instance.SendRequest(new UnBanAccountMessage(reply.Account.Login),
ok => trigger.Reply("Account {0} unbanned", reply.Account.Login),
error =>
trigger.ReplyError("Account {0} not unbanned : {1}", reply.Account.Login, error.Message)),
error =>
trigger.ReplyError("Player {0} not unbanned : {1}", character.Name, error.Message));
});
}
else
{
IPCAccessor.Instance.SendRequest(new UnBanAccountMessage(player.Account.Login),
ok => trigger.Reply("Account {0} unbanned", player.Account.Login),
error =>
trigger.ReplyError("Account {0} not unbanned : {1}", player.Account.Login, error.Message));
if (!player.Account.IsJailed)
{
return;
}
player.Account.IsJailed = false;
player.Account.BanEndDate = null;
player.Teleport(player.Breed.GetStartPosition());
player.SendServerMessage("Vous avez été libéré de prison.", Color.Red);
}
}
public bool IsChange(TriggerBase source)
{
if (this.colliderStyle != source.colliderStyle)
{
return(true);
}
if (this.center != source.center)
{
return(true);
}
if (this.boxSize != source.boxSize)
{
if (this.colliderStyle == ColliderStyle.BOX)
{
return(true);
}
else
{
return(false);
}
}
if (this.radius != source.radius)
{
if (this.colliderStyle == ColliderStyle.SPHERE)
{
return(true);
}
else
{
return(false);
}
}
if (this.mesh != source.mesh)
{
return(true);
}
if (this.lineWidth != source.lineWidth)
{
return(true);
}
if (this.isDraw != source.isDraw)
{
return(true);
}
return(false);
}
void OnEntityEnter(TriggerBase triggerbase, BaseEntity entity)
{
if (!hasStarted) return;
cachedBlock = triggerbase.GetComponentInParent<BuildingBlock>();
if (cachedBlock == null) return;
if (cachedBlock.blockDefinition.fullName != "build/block.halfheight") return;
cachedPlayer = entity.GetComponent<BasePlayer>();
if (cachedPlayer == null) return;
cachedBlock.Kill(BaseNetworkable.DestroyMode.Gib);
cachedPlayer.SendConsoleCommand("chat.add", new object[] { "0", string.Format("<color=orange>{0}:</color> {1}", "Warning", "You are not allowed to build blocks over you"), 1.0 });
}
public override void Execute(TriggerBase trigger)
{
if (trigger.Args.HasNext)
{
base.Execute(trigger);
}
else
{
trigger.Reply("Uptime : " + trigger.Bold("{0}") + " Players : " + trigger.Bold("{1}"), ServerBase.InstanceAsBase.UpTime.ToString(@"dd\.hh\:mm\:ss"), ServerBase.InstanceAsBase.ClientManager.Count);
}
}
public override void Execute(TriggerBase trigger)
{
foreach (var target in GetTargets(trigger))
{
var time = trigger.Get <int>("time");
target.Mute(TimeSpan.FromMinutes(time), trigger.User as Character);
trigger.Reply("{0} muted", target.Name);
target.OpenPopup(string.Format("Vous avez été muté pendant {0} minutes", time));
}
}
public override void Execute(TriggerBase trigger)
{
if (trigger.Args.HasNext)
{
base.Execute(trigger);
}
else
{
trigger.Reply("Temps sur Avalone : " + trigger.Bold("{0}") + "<br/> Joueurs en ligne sur Avalone: " + trigger.Bold("{1}"), ServerBase.InstanceAsBase.UpTime.ToString(@"dd\.hh\:mm\:ss"), ServerBase.InstanceAsBase.ClientManager.Count);
}
}
public override void Execute(TriggerBase trigger)
{
var count = trigger.Get <int>("count");
foreach (var client in FakeClientManager.Instance.AddAndConnectClients(count))
{
client.CreatorTrigger = trigger;
}
trigger.Reply("{0} fake clients connecting ...", count);
}
public Character GetTarget(TriggerBase trigger)
{
var targets = GetTargets(trigger);
if (targets.Length > 1)
{
throw new Exception("Only 1 target allowed");
}
return(targets[0]);
}
public override void Execute(TriggerBase trigger)
{
foreach (var target in GetTargets(trigger))
{
var statsPoints = trigger.Get <ushort>("amount");
target.StatsPoints = statsPoints;
target.RefreshStats();
trigger.Reply("{0} has now {1} stats points", target, statsPoints);
}
}
public override void AddTrigger(TriggerBase trigger)
{
if (_triggersIds.Contains(trigger.Id))
{
throw new InvalidOperationException("Trigger with same id already exist");
}
_triggers.Add(trigger);
_triggersIds.Add(trigger.Id);
_dataManager.Set(TriggersIdsKey, _triggersIds);
_dataManager.Set(trigger.Id, trigger);
}
private void Test_SetBindingValue_ValueChanged(TriggerBase <DependencyObject> trigger, StubAction stubAction, StubDataStore dataStore)
{
using (StubWindow window = new StubWindow(null))
{
// Change the value on the data store.
dataStore.Foo = "foo";
// Force the Data binding phase
DispatcherHelper.ForceDataBinding();
Assert.AreEqual(stubAction.InvokeCount, 1, "The trigger should have been invoked once.");
}
}
public override void Execute(TriggerBase trigger)
{
foreach (var target in GetTargets(trigger))
{
var to = ((GameTrigger)trigger).Character;
Character target1 = target;
target.Area.ExecuteInContext(() =>
target1.Teleport(to.Position));
}
}
/// <summary>
/// 获取
/// </summary>
/// <param name="trigger"></param>
/// <returns></returns>
public static TriggerModelLoader Get(TriggerBase trigger)
{
TriggerModelLoader loader = null;
if (trigger == null)
{
return loader;
}
loader = trigger.transform.GetComponent<TriggerModelLoader>();
if (loader == null)
{
loader = trigger.gameObject.AddComponent<TriggerModelLoader>();
}
loader.m_Trigger = trigger;
return loader;
}
public void SetInfo(ElevatorInfo info)
{
this.info = info;
var cwaypoints = Interface.CallHook("GetWaypointsList", this.info.WaypointsName);
if (cwaypoints == null)
{
Debug.Log(string.Format("{0} was destroyed, informations are invalid. Did you set waypoints? or a PrefabName?", info.Name));
GameObject.Destroy(this);
return;
}
this.waypoints = new List<WaypointInfo>();
foreach (var cwaypoint in (List<object>)cwaypoints)
{
foreach (KeyValuePair<Vector3, float> pair in (Dictionary<Vector3,float>)cwaypoint)
{
this.waypoints.Add(new WaypointInfo(pair.Key, pair.Value));
}
}
if (this.waypoints.Count < 2)
{
Debug.Log(string.Format("{0} waypoints were detected for {1}. Needs at least 2 waypoints. Destroying.", this.waypoints.Count.ToString(), info.Name));
GameObject.Destroy(this);
return;
}
this.rotation = new UnityEngine.Quaternion(Convert.ToSingle(info.rx), Convert.ToSingle(info.ry), Convert.ToSingle(info.rz), Convert.ToSingle(info.rw));
this.block = CreateBuildingBlock(this.info.PrefabName, this.waypoints[0].GetPosition(), this.rotation, Convert.ToInt32(this.info.Grade));
if(this.block == null)
{
Debug.Log(string.Format("Something went wrong, couldn't create the BuildingBlock for {0}", info.Name));
GameObject.Destroy(this);
return;
}
protectedBlock.Add(this.block.GetComponent<BaseCombatEntity>());
trigger = block.GetComponentInChildren<MeshCollider>().gameObject.AddComponent<TriggerBase>();
trigger.gameObject.name = "Elevator";
var newlayermask = new UnityEngine.LayerMask();
newlayermask.value = 133120;
trigger.interestLayers = newlayermask;
trigger.gameObject.layer = UnityEngine.LayerMask.NameToLayer("Trigger");
spawnedElevators.Add(this);
}
void OnEntityLeave(TriggerBase triggerbase, BaseEntity entity)
{
if (triggerbase == null || entity == null) return;
if (triggerbase.gameObject.name != "Elevator") return;
foreach (Elevator ele in spawnedElevators)
{
if (ele.trigger == triggerbase)
{
if (ele.collidingPlayers.Contains(entity))
ele.collidingPlayers.Remove(entity);
}
}
}
void OnEntityEnter(TriggerBase triggerbase, BaseEntity entity)
{
if (triggerbase == null || entity == null) return;
if (triggerbase.gameObject.name != "Elevator") return;
foreach (Elevator ele in spawnedElevators)
{
if (ele.trigger == triggerbase)
{
if (!ele.collidingPlayers.Contains(entity))
ele.collidingPlayers.Add(entity);
ele.ActivateMovement();
}
}
}
public override void OnInspectorGUI()
{
m_BaseTrigger = target as TriggerBase;
DrawAttr();
}
public void ChangeTriggerRadius(TriggerBase trigger, float newRadius)
{
if (newRadius < 0f)
throw new InvalidOperationException(String.Format("Radius can't be less then zero. ChangeTriggerRadius({0}, {1})",
trigger,
newRadius));
trigger.GetComponent<SphereCollider>().radius = newRadius;
trigger.SendMessage("OnValidate", SendMessageOptions.DontRequireReceiver);
}
/// <summary>
/// 父节点结束
/// </summary>
/// <param name="trigger"></param>
public void OnFatherTriggerFinish(TriggerBase trigger)
{
OnTrigger();
}
void OnEntityEnter(TriggerBase triggerbase, BaseEntity entity)
{
if (triggerbase.gameObject.name == "Jail")
{
if (entity.GetComponentInParent<BasePlayer>())
{
inJailZone.Add(entity.GetComponentInParent<BasePlayer>());
if (jaildata[entity.GetComponentInParent<BasePlayer>().userID.ToString()] == null)
{
if (entity.GetComponentInParent<BaseNetworkable>().net.connection.authLevel < 1)
{
SendReply(entity.GetComponentInParent<BasePlayer>(), "You are not allowed to enter the Jail");
SendPlayerAway(entity.GetComponentInParent<BasePlayer>(), triggerbase);
}
else
{
SendReply(entity.GetComponentInParent<BasePlayer>(), "Welcome {0} to the jail", entity.GetComponentInParent<BasePlayer>().displayName);
}
}
}
}
}
void OnEntityLeave(TriggerBase triggerbase, BaseEntity entity)
{
if (triggerbase.gameObject.name == "Jail")
{
if (entity.GetComponentInParent<BasePlayer>())
{
if (inJailZone.Contains(entity.GetComponentInParent<BasePlayer>()))
inJailZone.Remove(entity.GetComponentInParent<BasePlayer>());
if (jaildata[entity.GetComponentInParent<BasePlayer>().userID.ToString()] != null)
{
SendReply(entity.GetComponentInParent<BasePlayer>(), "You may not leave the Jail");
SendPlayerBack(entity.GetComponentInParent<BasePlayer>(), triggerbase);
}
}
}
}
void SendPlayerBack(BasePlayer player, TriggerBase triggerbase)
{
var ejectDirection = player.transform.position - triggerbase.transform.position;
Vector3 newpos = triggerbase.transform.position + ((ejectDirection / ejectDirection.magnitude) * (triggerbase.GetComponentInParent<UnityEngine.SphereCollider>().radius - 1));
ForcePlayerPosition(player, newpos);
}
private void OnEntityEnter(TriggerBase triggerBase, BaseEntity entity)
{
HookCalled("OnEntityEnter");
}
private void OnEntityLeave(TriggerBase triggerBase, BaseEntity entity)
{
HookCalled("OnEntityLeave");
}
