public static void RemoveFromGroup(Group group, ObjectGuid guid, RemoveMethod method = RemoveMethod.Default, ObjectGuid kicker = default(ObjectGuid), string reason = null)
{
if (!group)
{
return;
}
group.RemoveMember(guid, method, kicker, reason);
}
private void SubscriberMessageReceived(RedisChannel redisChannel, RedisValue redisValue)
{
if (!redisChannel.ToString().EndsWith("expired", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
var key = Encoding.UTF8.GetString(redisValue);
LogMethod?.Invoke("Expired", key, null);
RemoveMethod?.Invoke(key);
}
public void SetImplementedEvent(Event decl)
{
ImplementedEvent = decl;
UnoName = decl.DeclaringType + "." + decl.UnoName;
if (AddMethod != null && decl.AddMethod != null)
{
AddMethod.SetImplementedMethod(decl.AddMethod);
}
if (RemoveMethod != null && decl.RemoveMethod != null)
{
RemoveMethod.SetImplementedMethod(decl.RemoveMethod);
}
}
public override void Implement(DynamicTypeBuilder config, TypeBuilder typeBuilder)
{
var addMethodIL = AddMethod.GetILGenerator();
#region AddMethodIL
GenerateHandlerMethods(BackingField, addMethodIL, true);
#endregion
var removeMethodIL = RemoveMethod.GetILGenerator();
#region RemoveMethodIL
GenerateHandlerMethods(BackingField, removeMethodIL, false);
#endregion
}
/// <inheritdoc />
protected override void RemoveAt(ref IEnumerable collection, int collectionIndex)
{
int current = 0;
foreach (var item in collection)
{
if (current == collectionIndex)
{
#if DEV_MODE
Debug.Log("<color=red>RemoveAt(" + StringUtils.TypeToString(collection) + ", " + collectionIndex + "): " + StringUtils.ToString(item) + " with Type=" + StringUtils.TypeToString(item) + "</color>");
#endif
RemoveMethod.InvokeWithParameter(collection, item);
return;
}
current++;
}
}
public sealed override MethodInfo GetRemoveMethod(bool nonPublic) => RemoveMethod.FilterAccessor(nonPublic);
// Called when a member is removed from a group.
public virtual void OnRemoveMember(Group group, ObjectGuid guid, RemoveMethod method, ObjectGuid kicker, string reason)
{
}
public void RemoveFromGroup(RemoveMethod method = RemoveMethod.Default)
{
RemoveFromGroup(GetGroup(), GetGUID(), method);
}
public override void OnRemoveMember(Group group, ObjectGuid guid, RemoveMethod method, ObjectGuid kicker, string reason)
{
if (!Global.LFGMgr.isOptionEnabled(LfgOptions.EnableDungeonFinder | LfgOptions.EnableRaidBrowser))
{
return;
}
ObjectGuid gguid = group.GetGUID();
Log.outDebug(LogFilter.Lfg, "LFGScripts.OnRemoveMember [{0}]: remove [{1}] Method: {2} Kicker: {3} Reason: {4}", gguid, guid, method, kicker, reason);
bool isLFG = group.isLFGGroup();
if (isLFG && method == RemoveMethod.Kick) // Player have been kicked
{
/// @todo - Update internal kick cooldown of kicker
string str_reason = "";
if (!string.IsNullOrEmpty(reason))
{
str_reason = reason;
}
Global.LFGMgr.InitBoot(gguid, kicker, guid, str_reason);
return;
}
LfgState state = Global.LFGMgr.GetState(gguid);
// If group is being formed after proposal success do nothing more
if (state == LfgState.Proposal && method == RemoveMethod.Default)
{
// LfgData: Remove player from group
Global.LFGMgr.SetGroup(guid, ObjectGuid.Empty);
Global.LFGMgr.RemovePlayerFromGroup(gguid, guid);
return;
}
Global.LFGMgr.LeaveLfg(guid);
Global.LFGMgr.SetGroup(guid, ObjectGuid.Empty);
byte players = Global.LFGMgr.RemovePlayerFromGroup(gguid, guid);
Player player = Global.ObjAccessor.FindPlayer(guid);
if (player)
{
if (method == RemoveMethod.Leave && state == LfgState.Dungeon &&
players >= SharedConst.LFGKickVotesNeeded)
{
player.CastSpell(player, SharedConst.LFGSpellDungeonDeserter, true);
}
//else if (state == LFG_STATE_BOOT)
// Update internal kick cooldown of kicked
player.GetSession().SendLfgUpdateStatus(new LfgUpdateData(LfgUpdateType.LeaderUnk1), true);
if (isLFG && player.GetMap().IsDungeon()) // Teleport player out the dungeon
{
Global.LFGMgr.TeleportPlayer(player, true);
}
}
if (isLFG && state != LfgState.FinishedDungeon) // Need more players to finish the dungeon
{
Player leader = Global.ObjAccessor.FindPlayer(Global.LFGMgr.GetLeader(gguid));
if (leader)
{
leader.GetSession().SendLfgOfferContinue(Global.LFGMgr.GetDungeon(gguid, false));
}
}
}
/// <summary>
/// Manually removes selected status effect/s.
/// </summary>
/// <param name="target">Target who will get a new status effect.</param>
/// <param name="caster">Caster who applied status effect on the target. Can be NULL.</param>
/// <param name="scriptableStatusEffect">New scriptable status effect to be applied.</param>
/// <param name="isCasterImportant">Should the caster be added to filter for removation method?</param>
/// <param name="method">Method of the removation.</param>
public void RemoveStatusEffect(Character target, Character caster, ScriptableStatusEffect scriptableStatusEffect, bool isCasterImportant, RemoveMethod method)
{
if (target == null || scriptableStatusEffect == null)
{
Debug.unityLogger.Log(LogType.Error, "Null reference for removing a status effect!");
return;
}
// Remove all status effects of the same type.
if (method == RemoveMethod.RemoveAllOfTheSameType)
{
target.AppliedStatusEffects.RemoveAll(delegate(StatusEffect item)
{
if (item.Data.GetType() != scriptableStatusEffect.GetType())
{
return(false);
}
if (isCasterImportant)
{
if (item.Caster != caster)
{
return(false);
}
}
item.ForceEnd();
Debug.unityLogger.LogFormat(LogType.Log, "[{0}] Status effect ({1}) removed!", target.Name, item);
return(true);
});
}
// Remove all effects of the same effect.
else if (method == RemoveMethod.RemoveAllOfTheSameEffect)
{
target.AppliedStatusEffects.RemoveAll(delegate(StatusEffect item)
{
if (item.Data != scriptableStatusEffect)
{
return(false);
}
if (isCasterImportant)
{
if (item.Caster != caster)
{
return(false);
}
}
item.ForceEnd();
Debug.unityLogger.LogFormat(LogType.Log, "[{0}] Status effect ({1}) removed!", target.Name, item);
return(true);
});
}
// Remove only the first occured status effect.
else if (method == RemoveMethod.RemoveTheFirst)
{
target.AppliedStatusEffects.Remove(target.AppliedStatusEffects.First(delegate(StatusEffect item)
{
if (item.Data != scriptableStatusEffect)
{
return(false);
}
if (isCasterImportant)
{
if (item.Caster != caster)
{
return(false);
}
}
item.ForceEnd();
Debug.unityLogger.LogFormat(LogType.Log, "[{0}] Status effect ({1}) removed!", target.Name, item);
return(true);
}));
}
}
public Helper(RemoveMethod done)
{
remove = done;
}
public Helper(RemoveMethod done)
{
this.done = done;
}
public void SetOverriddenEvent(Event overriddenEvent)
{
OverriddenEvent = overriddenEvent;
AddMethod?.SetOverriddenMethod(overriddenEvent?.AddMethod);
RemoveMethod?.SetOverriddenMethod(overriddenEvent?.RemoveMethod);
}
/// <summary>
/// Tests that common aspects of the specified collection are functional.
/// </summary>
/// <param name="collection">An object that is the collection to be tested.</param>
public static void TestCollection(object collection)
{
if (collection != null)
{
Type MyType;
MyType = collection.GetType();
if (MyType.GetInterface("ICollection") != null)
{
Type[] GenericTypes;
GenericTypes = MyType.BaseType.GetGenericArguments();
if (GenericTypes != null && GenericTypes.Length == 1)
{
MethodInfo AddMethod;
PropertyInfo CountProperty;
PropertyInfo IndexerProperty;
MethodInfo RemoveMethod;
AddMethod = MyType.GetMethod("Add");
CountProperty = MyType.GetProperty("Count");
IndexerProperty = MyType.GetProperty("Item", GenericTypes[0], new Type[] { typeof(int) });
RemoveMethod = MyType.GetMethod("Remove");
if (AddMethod != null && RemoveMethod != null && CountProperty != null && IndexerProperty != null)
{
int CurrentCount;
CurrentCount = (int)CountProperty.GetValue(collection);
if (CurrentCount > 0)
{
object TestObject;
TestObject = IndexerProperty.GetValue(collection, new object[] { 0 });
if (TestObject != null)
{
Assert.AreEqual(CurrentCount, CountProperty.GetValue(collection));
RemoveMethod.Invoke(collection, new object[] { TestObject });
Assert.AreEqual(CurrentCount - 1, CountProperty.GetValue(collection));
AddMethod.Invoke(collection, new object[] { TestObject });
Assert.AreEqual(CurrentCount, CountProperty.GetValue(collection));
}
else
{
Assert.Fail("Indexer returned a null result");
}
}
else
{
throw new ArgumentException("The specified collection is empty and cannot be tested", "collection");
}
}
else
{
throw new ArgumentException("The specified type does not support required operations", "collection");
}
}
else
{
throw new ArgumentException("The specified type does not implement a generic collection", "collection");
}
}
else
{
throw new ArgumentException("The specified type does not implement ICollection", "collection");
}
}
else
{
throw new ArgumentException("The specified collection is null", "collection");
}
}