public void AddChannelList(string channelName)
{
if (!chatChannelList.Contains(channelName))
{
chatChannelList.Add(channelName);
}
}
public void Footstep(int index)
{
if (!Footsteps.Contains(index))
{
Footsteps.Add(index);
}
}
public bool Check(LogData log)
{
if (regexDomain != null)
{
var regexResult = regexDomain.Match(log.domain).Success;
if (regexResult == false)
{
// if we have a domain regex then it must match. if not the logdata is not valid
return(false);
}
}
if (regexMessage != null)
{
var regexMessageResult = regexMessage.Match(log.message).Success;
if (regexMessageResult == false)
{
// if we have a message regex then it must match. if not the logdata is not valid
return(false);
}
}
if (typesExcluded.Contains(log.type))
{
return(false);
}
return(true);
}
private void Awake()
{
audioSource = GetComponent <AudioSource>();
for (var i = 0; i < transform.childCount; i++)
{
var c = transform.GetChild(i).GetComponent <Candle>();
candleList.Add(c);
var r = (int)Random.Range(0, bodyLengthContainer.Count());
c.AddBody(bodyLengthContainer.ElementAt(r));
c.IsPlayable.Where(x => x)
.Subscribe(onPlayable =>
{
if (!LitCandleList.Contains(c))
{
LitCandleList.Add(c);
}
PlaySE();
c.BodyCount
.TakeUntil(c.BodyCount.Where(x => x == 0))
.Subscribe(count => _bgmPitch.Value = Mathf.InverseLerp(0.2f, 10f, 5 / Mathf.Clamp(count, 1, 5)));
});
c.IsPlayable.Where(x => !x)
.Subscribe(deActivate =>
{
c.transform.SetParent(transform);
});
}
}
/// <summary>
/// ファイルからメモリストの情報を読み出して引数のリストに追加する
/// </summary>
/// <param name="memoList">追加する対象のリスト</param>
/// <param name="filename">読み出すファイル</param>
/// <returns>追加された項目数</returns>
public static int LoadMemoFile(ReactiveCollection <SelfMemoItem> memoList, string filename)
{
int ret = 0;
ReactiveCollection <SelfMemoItem> _memo;
try
{
using (var ms = new FileStream(filename, FileMode.Open))
{
var serializer = new DataContractJsonSerializer(typeof(ReactiveCollection <SelfMemoItem>));
_memo = (ReactiveCollection <SelfMemoItem>)serializer.ReadObject(ms);
}
foreach (var m in _memo)
{
m.Initialize();
if (!memoList.Contains(m))
{
memoList.Add(m);
ret++;
}
}
}
catch (Exception e)
{
//error
}
return(ret);
}
protected override void OnEnable()
{
_lifeTime?.Release();
GameLog.Log("GameFlowWindow : OnEnable");
graph = null;
base.OnEnable();
_lifeTime.AddCleanUpAction(() => windows.Remove(this));
if (!windows.Contains(this))
{
windows.Add(this);
}
MessageBroker.Default
.Receive <UniGraphSaveMessage>()
.Where(x => x.graph == _targetGraph)
.Do(x => Save())
.Subscribe()
.AddTo(_lifeTime);
MessageBroker.Default
.Receive <UniGraphReloadMessage>()
.Where(x => x.graph == _targetGraph)
.Do(x => Save())
.Do(x => Reload())
.Subscribe()
.AddTo(_lifeTime);
Reload();
}
public virtual void Initialize(IEventSystem eventSystem, IPoolManager poolManager)
{
Components = new Type[] { typeof(T1), typeof(T2) };
EventSystem = eventSystem;
EntityPool = poolManager.GetPool();
cachedEntities.ObserveAdd().Select(x => x.Value).Subscribe(entity => {
if (Predicates.Count == 0)
{
PreAdd(entity);
AddEntity(entity);
return;
}
var bools = new List <ReactiveProperty <bool> >();
foreach (var predicate in Predicates)
{
bools.Add(predicate.Invoke(entity));
}
var onLatest = Observable.CombineLatest(bools.ToArray());
onLatest.DistinctUntilChanged().Subscribe(values => {
if (values.All(value => value == true))
{
PreAdd(entity);
AddEntity(entity);
}
else
{
PreRemove(entity);
RemoveEntity(entity);
}
}).AddTo(this.Disposer);;
}).AddTo(this.Disposer);
cachedEntities.ObserveRemove().Select(x => x.Value).Subscribe(entity => {
PreRemove(entity);
RemoveEntity(entity);
}).AddTo(this.Disposer);
foreach (IEntity entity in EntityPool.Entities)
{
if (entity.Has(Components.ToArray()))
{
cachedEntities.Add(entity);
}
}
EventSystem.OnEvent <EntityAddedEvent>().Where(_ => _.Entity.Has(Components.ToArray()) && cachedEntities.Contains(_.Entity) == false).Subscribe(_ => { cachedEntities.Add(_.Entity); });
EventSystem.OnEvent <EntityRemovedEvent>().Where(_ => cachedEntities.Contains(_.Entity)).Subscribe(_ => { cachedEntities.Remove(_.Entity); });
EventSystem.OnEvent <ComponentAddedEvent>().Where(_ => _.Entity.Has(Components.ToArray()) && cachedEntities.Contains(_.Entity) == false).Subscribe(_ => { cachedEntities.Add(_.Entity); });
EventSystem.OnEvent <ComponentRemovedEvent>().Where(_ => Components.Contains(_.Component.GetType()) && cachedEntities.Contains(_.Entity)).Subscribe(_ => { cachedEntities.Remove(_.Entity); });
}
public virtual void CancelCommand(CommandBase command)
{
command.CurrentState = CommandState.Canceled;
lock (_lockingQueue)
{
if (_outstandingCommands.Contains(command))
{
_outstandingCommands.Remove(command);
}
}
}
// tileを選択
private void SelectTile()
{
var currentPointData = new PointerEventData(EventSystem.current)
{
position = Input.mousePosition
};
EventSystem.current.RaycastAll(currentPointData, rayResult);
// 飛ばしたrayの中にtileが含まれているか
var tile = rayResult
.Select(x => x.gameObject.GetComponent <ITile>())
.FirstOrDefault(x => x != null);
if (tile == null)
{
return;
}
audioManager.PlaySE(SfxType.TileClick);
var coordinates = tile.Coordinates;
var frontTile = tileSpawner.GetTile(coordinates);
// 現在の選択するによって場合分け
switch (selectedCoordinates.Count())
{
case 0:
if (frontTile == null)
{
return;
}
frontTile.SetIsSelected(true);
selectedCoordinates.Add(coordinates);
break;
case 1:
if (selectedCoordinates.Contains(coordinates))
{
selectedCoordinates.Remove(coordinates);
if (frontTile != null)
{
frontTile.SetIsSelected(false);
}
}
else
{
selectedCoordinates.Add(coordinates);
}
break;
}
}
/// <summary>
/// Add an element to view and immediately go in editview (or specifiy not to do so)
/// </summary>
/// <param name="elem"></param>
/// <param name="addInEditMode"></param>
public void AddElement(DevUIElement elem, bool addInEditMode = true)
{
if (!uiElements.Contains(elem))
{
uiElements.Add(elem);
_eventsService.Publish(new Events.NewUIElement()
{
view = this,
elem = elem,
inEditMode = addInEditMode
});
}
}
private void Start()
{
allAsteroidPresenter = new ReactiveCollection <AsteroidPresenter>();
MessageBroker.Default
.Receive <DeathNotice>()
.Where(msg => msg.objectType == SpaceObjectType.asteroidPresenter)
.Subscribe(msg =>
{
if (allAsteroidPresenter.Contains(msg.sender as AsteroidPresenter))
{
allAsteroidPresenter.Remove(msg.sender as AsteroidPresenter);
}
})
.AddTo(this);
}
public void IListSmokeTest()
{
var fixture = new ReactiveCollection <string>() as IList;
Assert.NotNull(fixture);
var pos = fixture.Add("foo");
Assert.Equal(0, pos);
Assert.Equal(1, fixture.Count);
Assert.True(fixture.Contains("foo"));
fixture.Insert(0, "bar");
Assert.Equal(0, fixture.IndexOf("bar"));
Assert.Equal(1, fixture.IndexOf("foo"));
Assert.Equal("bar", fixture[0] as string);
Assert.Equal("foo", fixture[1] as string);
var arr = new string[2];
fixture.CopyTo(arr, 0);
Assert.Equal(2, arr.Length);
Assert.Equal("bar", arr[0]);
Assert.Equal("foo", arr[1]);
fixture[1] = "baz";
Assert.Equal(1, fixture.IndexOf("baz"));
Assert.Equal(-1, fixture.IndexOf("foo"));
Assert.Equal("baz", fixture[1] as string);
Assert.False(fixture.Contains("foo"));
Assert.True(fixture.Contains("baz"));
fixture.Remove("bar");
Assert.Equal(1, fixture.Count);
Assert.False(fixture.Contains("bar"));
}
protected override void OnEnable()
{
_lifeTime?.Release();
GameLog.Log("GameFlowWindow : OnEnable");
graph = null;
base.OnEnable();
_lifeTime.AddCleanUpAction(() => windows.Remove(this));
if (!windows.Contains(this))
{
windows.Add(this);
}
Reload();
}
public void EmitPanel(PanelEntity entity)
{
if (_load.Contains(entity))
{
foreach (var load in _load.Reverse())
{
if (load == entity)
{
break;
}
_load.Remove(load);
}
}
else
{
_load.Add(entity);
}
}
public void SetFocustMonster(MonsterModel model)
{
if (model == focusMonster.Value)
{
if (!selectedMosnters.Contains(model))
{
selectedMosnters.Add(model);
}
else
{
selectedMosnters.Remove(model);
}
return;
}
int index = monsters.IndexOf(model);
this.focusMonster.Value = monsters[index];
}
private void Start()
{
allBulletsPresenter = new ReactiveCollection <BulletPresenter>();
MessageBroker.Default
.Receive <DeathNotice>()
.Where(msg => msg.objectType == SpaceObjectType.bulletPresenter)
.Subscribe(msg =>
{
if (allBulletsPresenter.Contains(msg.sender as BulletPresenter))
{
allBulletsPresenter.Remove(msg.sender as BulletPresenter);
}
})
.AddTo(this);
MessageBroker.Default
.Receive <ShootNotice>()
.Subscribe(msg =>
{
AddBulletPresenter(msg.startPosition);
})
.AddTo(this);
}
public override void OnEnable()
{
base.OnEnable();
SceneManager.sceneLoaded += OnSceneLoaded;
SceneManager.sceneUnloaded += OnSceneUnloaded;
sceneLoaders.OnAdd().Subscribe(entity =>
{
var sceneLoader = entity.GetComponent <SceneLoader>();
entity.OnListenerAsObservable <TriggerEnterEvent>().Select(_ => true)
.Merge(entity.OnListenerAsObservable().Select(_ => true))
.Subscribe(_ =>
{
foreach (var setup in sceneLoader.LoadQueue)
{
if (setup.Operation == SceneLoader.Operation.Load)
{
EventSystem.Send(new LoadSceneEvent(setup.SceneSetup));
}
else if (setup.Operation == SceneLoader.Operation.Unload)
{
EventSystem.Send(new UnloadSceneEvent(setup.SceneSetup));
}
}
}).AddTo(this.Disposer).AddTo(sceneLoader.Disposer);
}).AddTo(this.Disposer);
loadingScreens.OnAdd().Subscribe(entity =>
{
var loadingScreen = entity.GetComponent <LoadingScreen>();
loadingScreen.State.DistinctUntilChanged().Where(state => state == FadeState.FadedOut).Subscribe(_ =>
{
if (loadingScreens.Entities.Select(e => e.GetComponent <LoadingScreen>().State.Value).All(state => state != FadeState.FadingIn && state != FadeState.FadingOut))
{
readyToLoad.Value = true;
}
}).AddTo(this.Disposer).AddTo(loadingScreen.Disposer);
}).AddTo(this.Disposer);
EventSystem.OnEvent <LoadSceneEvent>().Subscribe(evt =>
{
foreach (var setup in evt.LoadSceneSetup.Setups)
{
if ((setup.Mode == LoadSceneMode.Additive && SceneManager.GetSceneByPath(setup.Path).isLoaded) || scenesToLoad.Contains(setup))
{
continue;
}
scenesToLoad.Add(setup);
}
}).AddTo(this.Disposer);
EventSystem.OnEvent <UnloadSceneEvent>().Subscribe(evt =>
{
foreach (var setup in evt.UnloadSceneSetup.Setups)
{
var scene = SceneManager.GetSceneByPath(setup.Path);
if (!scene.IsValid() || !scene.isLoaded || scenesToUnload.Contains(setup))
{
continue;
}
scenesToUnload.Add(setup);
}
}).AddTo(this.Disposer);
EventSystem.OnEvent <LoadSceneEvent>().Select(evt => evt.LoadSceneSetup).Merge(EventSystem.OnEvent <UnloadSceneEvent>().Select(evt => evt.UnloadSceneSetup))
.Where(_ => !readyToLoad.Value && scenesToLoad.Count + scenesToUnload.Count > 0).Subscribe(setup =>
{
var isReady = true;
foreach (var loadingScreen in loadingScreens.Entities.Select(entity => entity.GetComponent <LoadingScreen>()))
{
if (setup.LoadingMask.Contains(loadingScreen.Layer))
{
loadingScreen.State.Value = FadeState.FadingOut;
isReady = false;
}
}
readyToLoad.Value = isReady;
}).AddTo(this.Disposer);
scenesToLoad.ObserveAdd().Subscribe(evt =>
{
readyToLoad.StartWith(readyToLoad.Value).Where(isReady => isReady).FirstOrDefault().Subscribe(_ =>
{
SceneManager.LoadSceneAsync(evt.Value.Path, evt.Value.Mode);
}).AddTo(this.Disposer);
}).AddTo(this.Disposer);
scenesToUnload.ObserveAdd().Subscribe(evt =>
{
readyToLoad.StartWith(readyToLoad.Value).Where(isReady => isReady).FirstOrDefault().Subscribe(_ =>
{
SceneManager.UnloadSceneAsync(evt.Value.Path);
}).AddTo(this.Disposer);
}).AddTo(this.Disposer);
scenesToLoad.ObserveRemove().Merge(scenesToUnload.ObserveRemove())
.Where(_ => scenesToLoad.Count <= 0 && scenesToUnload.Count <= 0)
.Subscribe(_ =>
{
readyToLoad.Value = false;
Resources.UnloadUnusedAssets();
foreach (var loadingScreen in loadingScreens.Entities.Select(entity => entity.GetComponent <LoadingScreen>()).Where(loadingScreen => loadingScreen.State.Value == FadeState.FadingOut || loadingScreen.State.Value == FadeState.FadedOut))
{
loadingScreen.State.Value = FadeState.FadingIn;
}
}).AddTo(this.Disposer);
}
/// <summary>
/// csvからメモリストを読み込んで指定のリストに追加する
/// </summary>
/// <param name="memoList">追加する対象のリスト</param>
/// <param name="filename">csvファイル</param>
/// <returns>追加された項目数</returns>
public static int AddMemoFromCsv(ReactiveCollection <SelfMemoItem> memoList, string filename)
{
if (Path.GetExtension(filename).ToLower() != ".csv")
{
return(0);
}
int ret = 0;
FileInfo info = new FileInfo(filename);
Encoding enc;
// 文字コードを判別
using (FileReader reader = new FileReader(info))
{
enc = reader.Read(info).GetEncoding();
}
try
{
StreamReader sr = new StreamReader(filename, enc);
string line = "";
while (true)
{
int cnt = 0;
bool detectLineBreak = false;
line = sr.ReadLine();
if (line == null)
{
break;
}
cnt = CountOf(line, "\""); // ダブルクオートの数（改行の有無判断に使用）
do
{
if (detectLineBreak)
{
// 改行が検出された。もう一行読み出して末尾につなげる
var str = sr.ReadLine();
if (str == null)
{
break;
}
line += "\n" + str;
// ダブルクオートの数が偶数なら改行フラグ継続
cnt = CountOf(str, "\"");
detectLineBreak = (cnt % 2 == 0);
}
else
{
// 通常なら、ダブルクオート数の偶奇で改行の有無を判断
detectLineBreak = !(cnt % 2 == 0);
}
} while (detectLineBreak);
var separated = line.Split(',');
if (separated.Length >= 4)
{
var m = new SelfMemoItem(separated[0].Trim('\"'), separated[1].Trim('\"'), separated[2].Trim('\"'), separated[3].Trim('\"'));
if (!memoList.Contains(m))
{
memoList.Add(m);
ret++;
}
}
}
sr.Close();
}
catch (Exception e)
{
//error
}
return(ret);
}
public void IListTSmokeTest()
{
var fixture = new ReactiveCollection <string>() as IList <string>;
Assert.NotNull(fixture);
fixture.Add("foo");
Assert.Equal(1, fixture.Count);
Assert.True(fixture.Contains("foo"));
fixture.Insert(0, "bar");
Assert.Equal(0, fixture.IndexOf("bar"));
Assert.Equal(1, fixture.IndexOf("foo"));
Assert.Equal("bar", fixture[0]);
Assert.Equal("foo", fixture[1]);
var genericEnum = ((IEnumerable <string>)fixture).GetEnumerator();
Assert.NotNull(genericEnum);
bool result = genericEnum.MoveNext();
Assert.True(result);
Assert.Equal("bar", genericEnum.Current);
result = genericEnum.MoveNext();
Assert.True(result);
Assert.Equal("foo", genericEnum.Current);
result = genericEnum.MoveNext();
Assert.False(result);
var plainEnum = ((IEnumerable)fixture).GetEnumerator();
Assert.NotNull(plainEnum);
result = plainEnum.MoveNext();
Assert.True(result);
Assert.Equal("bar", plainEnum.Current as string);
result = plainEnum.MoveNext();
Assert.True(result);
Assert.Equal("foo", plainEnum.Current as string);
result = plainEnum.MoveNext();
Assert.False(result);
var arr = new string[2];
fixture.CopyTo(arr, 0);
Assert.Equal(2, arr.Length);
Assert.Equal("bar", arr[0]);
Assert.Equal("foo", arr[1]);
fixture[1] = "baz";
Assert.Equal(1, fixture.IndexOf("baz"));
Assert.Equal(-1, fixture.IndexOf("foo"));
Assert.Equal("baz", fixture[1]);
Assert.False(fixture.Contains("foo"));
Assert.True(fixture.Contains("baz"));
fixture.RemoveAt(1);
Assert.False(fixture.Contains("baz"));
fixture.Remove("bar");
Assert.Equal(0, fixture.Count);
Assert.False(fixture.Contains("bar"));
}
// すでにいるプレイヤーか確かめる
public bool IsExistPlayer(int playerID)
{
return(_playerIDList.Contains(playerID));
}
public bool Contains(IView view) => _views.Contains(view);