// Note: Static utility members specific to a feature colocated with the feature.
public override void Destroy(DestroyType typ, Outfit referenceOutfit)
{
Observers.SendDestroy(this, typ, referenceOutfit);
// Don't worry about unknown assessories/components added improperly to the outfit. If that is
// important to the user, the user can create a bake extension to handle it.
for (int i = 0; i < m_Accessories.Count; i++)
{
if (m_Accessories[i])
{
m_Accessories[i].RemoveObserver(this);
m_Accessories[i].Destroy(typ);
}
}
Reset();
if (typ == DestroyType.GameObject)
{
gameObject.SafeDestroy();
}
else
{
this.SafeDestroy();
}
}
public IDisposable AddObserver(IObserver <TEvent> observer)
{
var token = new ObserverToken(RemoveObserver);
Observers.TryAdd(token.Id, observer);
return(token);
}
public void Register(IObserver observer)
{
if (!Observers.Contains(observer))
{
Observers.Add(observer);
}
}
public void Detach(IObserver observer)
{
if (Observers.Contains(observer))
{
Observers.Remove(observer);
}
}
public void RemoveSpectator(PlayerInfo info)
{
if (Observers.ContainsKey(info.UserId))
{
Observers.Remove(info.UserId);
}
}
private void StopAllButton_Click(object sender, EventArgs e)
{
foreach (Observer observer in Observers.Where(observer => observer.IsObserving))
{
observer.Stop();
}
}
public override void Trigger()
{
try
{
_activator.UseCommand(currentCommand =>
{
if (_activator.Prepare != null)
{
_activator.Prepare(currentCommand, null);
}
if (_activator.IsQuery)
{
OleDbDataAdapter ada = new OleDbDataAdapter(currentCommand);
DataTable table = new DataTable();
ada.Fill(table);
Observers.PropagateOnNext(table);
}
else
{
currentCommand.ExecuteNonQuery();
}
});
}
catch (Exception ex)
{
Observers.PropagateOnError(ex);
}
finally
{
_activator.Release();
}
}
public void Subscribe(IObserver observer)
{
if (!Observers.Contains(observer))
{
Observers.Add(observer);
}
}
public void Remove(IList <IObserver> observers)
{
foreach (var observer in observers)
{
Observers.Remove(observer);
}
}
public void VisualizationClosed()
{
foreach (var handle in Observers.ToList())
{
CloseObserver(handle.Definition);
}
}
public void Add(IList <IObserver> observers)
{
foreach (var observer in observers)
{
Observers.Add(observer);
}
}
public virtual bool Update(DataType data)
{
if (data == null)
{
return(false);
// throw new ArgumentNullException(typeof(DataType).Name);
}
KeyType id = GetId(data);
DataType targetData = DataSet.FirstOrDefault(d => GetId(d).Equals(id));
if (targetData == null)
{
return(false);
// throw new ArgumentException($"{typeof(DataType)} with ID {id} does not exist!");
}
if (!ReferenceEquals(targetData, data))
{
Updater.Update(targetData, data);
}
foreach (IObserver <DataChanged <DataType> > observer in Observers.ToList())
{
observer.OnNext(new DataChanged <DataType>(DataChangedAction.Update, new List <DataType> {
data
}));
}
return(true);
}
public IDisposable Subscribe(Action <object> onNext)
{
var observer = new ObserverAction(onNext);
Observers.Add(observer);
return(new INPCListenerDisposer(this, observer));
}
public void Unsubscribe(IObserver observer)
{
if (Observers.Contains(observer))
{
this.Observers.Remove(observer);
}
}
public void Dispose()
{
if (!(Observer == null))
{
Observers.Remove(Observer);
}
}
public void Dispose()
{
if (Observers.Contains(this.Observer))
{
Observers.Remove(this.Observer);
}
}
public void Dispose()
{
if ((Observers != null) && Observers.Contains(Observer))
{
Observers.Remove(Observer);
}
}
private void BroadcastMessage(object msg)
{
Challenger.Session.SendAsync(msg).Wait();
Challenged.Session.SendAsync(msg).Wait();
Observers.Select(x => x.Session).SendAsync(msg).Wait();
}
public void Clear(Player winner, Player loser)
{
Free = true;
Started = false;
BroadcastMessage(new SDuelBroadcastRound()
{
Flag = 1
});
BroadcastMessage(new SDuelBroadcastResult(winner.Character.Name, loser.Character.Name));
Challenger.Session.SendAsync(new SDuelAnsExit(DuelResults.NoError, (ushort)Challenged.Session.ID, Challenged.Character.Name)).Wait();
Challenged.Session.SendAsync(new SDuelAnsExit(DuelResults.NoError, (ushort)Challenger.Session.ID, Challenger.Character.Name)).Wait();
Observers.ForEach(x => x.Character.Spells.ClearBuffByEffect(SkillStates.DuelInterface).Wait());
Observers.Clear();
ChallengerPoints = 0;
ChallengedPoints = 0;
Challenger.Character.Duel = null;
Challenged.Character.Duel = null;
Challenger.Character.CharacterRegen -= Character_CharacterRegen;
Challenged.Character.CharacterRegen -= Character_CharacterRegen;
Challenger.Character.PlayerDie -= ChallengerDie;
Challenged.Character.PlayerDie -= ChallengedDie;
Challenger.Character.WarpTo(17).Wait();
Challenged.Character.WarpTo(17).Wait();
Challenger = null;
Challenged = null;
}
public void MoveToObserver(Player player)
{
if (State != GameState.Lobby)
{
return;
}
if (player.Type == (int)PlayerType.Observer)
{
return;
}
if (IsReady[player.Type])
{
return;
}
int oldType = player.Type;
Players[player.Type] = null;
IsReady[player.Type] = false;
Observers.Add(player);
BinaryWriter change = GamePacketFactory.Create(StocMessage.HsPlayerChange);
change.Write((byte)((player.Type << 4) + (int)PlayerChange.Observe));
SendToAll(change);
player.Type = (int)PlayerType.Observer;
player.SendTypeChange();
if (OnPlayerMove != null)
{
OnPlayerMove(this, new PlayerMoveEventArgs(player, oldType));
}
}
public void BroadcastRound()
{
Observers.Select(x => x.Session).SendAsync(new SDuelBroadcastRound()
{
Flag = 0
}).Wait();
}
public async Task BecomeConsumer(Guid streamId, string streamNamespace, string providerName, bool sendEvensOnly)
{
_logger = logger;
if (logger.IsVerbose)
{
logger.Verbose("BecomeConsumer StreamId={0} StreamProvider={1} Filter={2} Grain={3}",
streamId, providerName, sendEvensOnly, this.AsReference <IFilteredStreamConsumerGrain>());
}
InitStream(streamId, streamNamespace, providerName);
var observer = new MyStreamObserver <int>(logger);
StreamFilterPredicate filterFunc;
object filterData;
if (sendEvensOnly)
{
filterFunc = FilterIsEven;
filterData = FilterDataEven;
}
else
{
filterFunc = FilterIsOdd;
filterData = FilterDataOdd;
}
var subsHandle = await State.Stream.SubscribeAsync(observer, null, filterFunc, filterData);
State.ConsumerSubscriptionHandles.Add(subsHandle);
Observers.Add(subsHandle, observer);
await WriteStateAsync();
}
void Awake()
{
music = GetComponent <AudioSource>();
music.ignoreListenerVolume = true;
baseVolume = music.volume;
Observers.Subscribe(this, Tags.Options.MusicLevel, Tags.Options.SoundLevel);
if (PlayerPrefs.HasKey(Tags.Options.SoundLevel)) // set volumes from stored values
{
AudioListener.volume = PlayerPrefs.GetInt(Tags.Options.SoundLevel) / 100.0f;
}
else
{
PlayerPrefs.SetInt(Tags.Options.SoundLevel, 100);
}
if (PlayerPrefs.HasKey(Tags.Options.MusicLevel)) // set volumes from stored values
{
music.volume = baseVolume * PlayerPrefs.GetInt(Tags.Options.MusicLevel) / 100.0f;
}
else
{
PlayerPrefs.SetInt(Tags.Options.MusicLevel, 100);
}
PlayerPrefs.Save();
}
protected void NotifyError(Exception error)
{
foreach (var o in Observers.ToArray())
{
o.OnError(error);
}
}
protected void NotifyCompleted()
{
foreach (var o in Observers.ToArray())
{
o.OnCompleted();
}
}
/// <summary>
/// Notifies the observer of a new value in the sequence. It's best to override Dispatch or TreatRow than this method because this method contains pipelining logic.
/// </summary>
public override void Trigger()
{
CountTreated++;
try
{
IEnumerator fList = null;
if (_strm != null)
{
using (StreamReader reader = new StreamReader(_strm))
{
fList = FluentFile.For(_type).From(reader).GetEnumerator();
}
}
else if (_strmReader != null)
{
fList = FluentFile.For(_type).From(_strmReader).GetEnumerator();
}
else if (_filename != null)
{
fList = FluentFile.For(_type).From(_filename).GetEnumerator();
}
IterateElements(fList);
}
catch (Exception ex)
{
log4net.LogManager.GetLogger(this.GetType()).Error("Operation error", ex);
Observers.PropagateOnError(ex);
}
Completed = true;
Observers.PropagateOnCompleted();
}
private void IterateElements(IEnumerator fList)
{
while (fList.MoveNext())
{
Observers.PropagateOnNext(Row.FromObject(fList.Current));
}
}
/// <summary>
/// Notifies the observer of a new value in the sequence. It's best to override Dispatch or TreatRow than this method because this method contains pipelining logic.
/// </summary>
public override void Trigger()
{
CountTreated++;
try
{
foreach (var elt in _enumeration)
{
if (elt is Row)
{
Observers.PropagateOnNext(elt as Row);
}
else
{
Observers.PropagateOnNext(Row.FromObject(elt));
}
}
}
catch (Exception ex)
{
Observers.PropagateOnError(ex);
}
Completed = true;
Observers.PropagateOnCompleted();
}
/// <summary>
/// Searches the internal list of Observers to find a match to the given name. The match is partial and the name
/// does not have to be exact. The first found instance will be returned.
/// </summary>
/// <param name="partialName">String that should be matched to the name string of the observer.</param>
/// <returns>The first matching observer. If no match is found then an exception will be thrown.</returns>
public Observer GetObserverByPartialName(string partialName)
{
return(Observers.Find(delegate(Observer obs)
{
return obs.Name.Contains(partialName);
}));
}
private void AddObserversFromFile(string path)
{
var observerSettingsList = ObserversFile.Load(path);
if (observerSettingsList.Count == 0)
{
using (var centerAligner = new DialogCenterAligner(this))
{
MessageBox.Show(Resources.FailedOpenFile + "\n" + path, Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return;
}
if (!RecentFiles.Exists || RecentFiles.CanWrite)
{
RecentFiles.Add(path);
}
var tabPages = new TabPage[observerSettingsList.Count];
for (int i = 0; i < observerSettingsList.Count; i++)
{
var observer = new Observer(ObservedProcess, observerSettingsList[i]);
Observers.Add(observer);
var observerTabPage = new ObserverTabPage(Observers.Count - 1, observer);
tabPages[i] = observerTabPage;
}
ObserverTabControl.TabPages.AddRange(tabPages);
}
public void RemoveObserver(Observers o)
{
int i = Observers.IndexOf(o);
if(i >= 0)
{
Observers.Remove(o);
}
}
public static void AddObserver(Observers.BaseHttpModifyRequestObserver observer)
{
if (observer._isRegistered) return;
_observerService.Instance.AddObserver(observer, ObserverNotifications.HttpRequests.HttpOnModifyRequest, false);
}
public static void RemoveObserver(Observers.BaseHttpRequestResponseObserver observer)
{
if (!observer._isRegistered) return;
_observerService.Instance.RemoveObserver(observer, ObserverNotifications.HttpRequests.HttpOnModifyRequest);
_observerService.Instance.RemoveObserver(observer, ObserverNotifications.HttpRequests.HttpOnExamineResponse);
}
public void RegisterObserver(Observers o)
{
Observers.Add(o);
}
