public void RegisterTriggerEnter(UnityAction <Collider> evt)
{
if (triggerEnterEvent == null)
{
triggerEnterEvent = new TriggerEnterEvent();
}
triggerEnterEvent.AddListener(evt);
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.tag == "Controller")
{
note.Play();
triggerEvent = new TriggerEnterEvent(sound, Record.Instance.recordStartTime, padIndex);
SoundBandManager.Instance.HitColor(GetComponent <MeshRenderer>().material.GetColor("_EmissionColor"));
}
}
void Handle(TriggerEnterEvent e)
{
if (e.egoComponent1.HasComponents <RoomSwitchComponent>() && e.egoComponent2.HasComponents <RoomSwitchAgentComponent>())
{
// The first colliding GameObject is an edible
DealWithCollision(e.egoComponent1, e.egoComponent2);
}
else if (e.egoComponent1.HasComponents <RoomSwitchAgentComponent>() && e.egoComponent2.HasComponents <RoomSwitchComponent>())
{
// The first colliding GameObject is an edible
DealWithCollision(e.egoComponent1, e.egoComponent2);
}
}
void Handle(TriggerEnterEvent e)
{
if (e.egoComponent1.HasComponents <ObstacleComponent>() && e.egoComponent2.HasComponents <VulnerableComponent>())
{
// The first colliding GameObject is an edible
DealWithCollision(e.egoComponent1, e.egoComponent2);
}
else if (e.egoComponent1.HasComponents <VulnerableComponent>() && e.egoComponent2.HasComponents <ObstacleComponent>())
{
// The second colliding GameObject is a brick
DealWithCollision(e.egoComponent2, e.egoComponent1);
}
}
void Handle(TriggerEnterEvent e)
{
if (e.egoComponent1.HasComponents <EdibleComponent>() && e.egoComponent2.HasComponents <MouthComponent>())
{
// The first colliding GameObject is an edible
EatEdible(e.egoComponent1, e.egoComponent2);
}
else if (e.egoComponent1.HasComponents <MouthComponent>() && e.egoComponent2.HasComponents <EdibleComponent>())
{
// The second colliding GameObject is an edible
EatEdible(e.egoComponent2, e.egoComponent1);
}
}
private IEnumerator IePlayNote(TriggerEnterEvent note)
{
note.isPlaying = true;
AudioSource playableSource = sourcePool.First(source => !source.isPlaying);
playableSource.clip = note.sound;
playableSource.Play();
//playableSource.loop = true;
yield return(new WaitForSeconds(note.length));
//playableSource.Stop();
note.isPlaying = false;
}
public void AddPressButtonEvent(TriggerEnterEvent padEvent, Color padColor)
{
if (!isRecording)
{
return;
}
record.Add(padEvent);
int lowestNote = record.Min(note => note.padIndex);
int highestNote = record.Max(note => note.padIndex);
rowCount = Mathf.Max(highestNote - lowestNote + 1, 5);
// Track node 출력 부분
GameObject temp = Instantiate(nodeUIprefab, recordBg.rectTransform);
float noteHeight = TRACKGROUP_HEIGHT / rowCount;
temp.GetComponent <RectTransform>().sizeDelta = new Vector2((padEvent.length / SECONDS * TRACKGROUP_WIDTH) * 2, noteHeight);
temp.GetComponent <RectTransform>().anchoredPosition = new Vector2((padEvent.timeOffset * TRACKGROUP_WIDTH / SECONDS), -(noteHeight * (highestNote - padEvent.padIndex)));
//recordBg.uvRect = new Rect(0, 0, 50, noteHeight);
temp.gameObject.name = padEvent.padIndex.ToString();
temp.SetActive(true);
temp.GetComponent <Image>().color = padColor;
if (prevRowNote != lowestNote)
{
SortingHeight(highestNote, noteHeight);
}
if (prevTopNote != highestNote)
{
SortingHeight(highestNote, noteHeight);
}
prevTopNote = highestNote;
prevRowNote = lowestNote;
// 민찬
//DataManager.Instance.OnRecordSave(padEvent.sound.name, padEvent.timeoffset, padEvent.length, padEvent.startTime);
}
public override void OnEnable()
{
base.OnEnable();
NetwrokTimeline.OnForward(data =>
{
for (int i = 0; i < data.UserInputData[0].Length; i++)
{
for (int j = 0; j < data.UserInputData[0][i].Inputs.Length; j++)
{
var userId = data.UserInputData[0][i].UserId;
var eventInput = data.UserInputData[0][i].GetInput <EventInput>(j);
if (eventInput.Type == EventCode.GameStart)
{
var isRoomOwner = eventInput.Get <bool>(0);
if (!HasUser(userId))
{
var pos = isRoomOwner ? NetworkPlayerPrefab.transform.position + new Vector3(2, 0, -5) : NetworkPlayerPrefab.transform.position += new Vector3(-2, 0, -5);
var rot = isRoomOwner ? Quaternion.Euler(0, -90, 0) : Quaternion.Euler(0, 90, 0);
NetworkPrefabFactory.Instantiate(userId, data.TickId, NetworkPlayerPrefab, pos, rot);
}
}
}
}
return(null);
}).AddTo(this.Disposer);
NetworkPlayerComponents.OnAdd().Subscribe(entity =>
{
if (NetworkPlayerComponents.Entities.Count == UserComponents.Entities.Count)
{
var evt = new TriggerEnterEvent();
evt.Source = GameStartId;
EventSystem.Send(evt);
}
}).AddTo(this.Disposer);
}
private void OnLogin(ReceiveData data)
{
string[] strs = data.StringValue.Split(Separator);
ReturnCode returnCode = (ReturnCode)int.Parse(strs[0]);
if (returnCode == ReturnCode.Success)
{
int userId = int.Parse(strs[1]);
string username = strs[2];
int totalCount = int.Parse(strs[3]);
int winCount = int.Parse(strs[4]);
var evt = new TriggerEnterEvent();
evt.Source = LobbyId;
EventSystem.Send(evt);
EventSystem.Send(new MessageEvent(LoginSuccessFeedback, LogType.Log));
EventSystem.Send(new SpawnUserEvent(userId, username, totalCount, winCount, true, false));
NetworkSystem.Publish(RequestCode.ListRooms, EmptyStr);
}
else
{
EventSystem.Send(new MessageEvent(UserNameOrPasswordIncorrectError, LogType.Error));
}
}
protected override void Update()
{
base.Update();
switch (state)
{
case LoopState.Pause:
break;
case LoopState.Ready:
startText.text = (metronome.maxBeats - (metronome.beats + metronome.maxBeats - 1) % metronome.maxBeats).ToString();
print($"{metronome.maxBeats} {metronome.beats}");
break;
case LoopState.Play:
break;
}
if (isPlaying && currentPlayTime <= recordLoop.recordLength)
{
currentPlayTime += Time.deltaTime;
shouldPlayNote = recordLoop.record.FirstOrDefault(r => r.isNowPlaying(currentPlayTime) && !r.isPlaying);
if (shouldPlayNote != null && shouldPlayNote.sound != null)
{
StartCoroutine(IePlayNote(shouldPlayNote));
}
}
else
{
if (!isLoop)
{
isPlaying = false;
SetState(LoopState.Pause);
}
currentPlayTime = 0;
}
}
/********** コライダーのトリガーがオンの場合使う **********/
private void OnTriggerEnter2D(Collider2D other)
{
// 衝突時に通知する
TriggerEnterEvent?.Invoke(other);
}
void OnTriggerEnter( Collider collider )
{
var e = new TriggerEnterEvent( egoComponent, collider.gameObject.GetComponent<EgoComponent>(), collider );
EgoEvents<TriggerEnterEvent>.AddEvent( e );
}
protected virtual void OnTriggerEnter(Collider other)
{
TriggerEnterUnityEvent.Invoke();
TriggerEnterEvent?.Invoke(this, other);
}
void OnTriggerEnter(Collider other)
{
TriggerEnterEvent?.Invoke(other.transform);
}
public void TriggerMine(TriggerEnterEvent e, ActiveMineNode mine, SingleNode <TankActiveStateComponent> tank)
{
base.ScheduleEvent <SendTankMovementEvent>(tank);
}
public void TakeBonus(TriggerEnterEvent e, SingleNode <BonusActiveStateComponent> bonus, SelfTankNode tank)
{
base.ScheduleEvent <SendTankMovementEvent>(tank);
base.NewEvent <BonusTakingRequestEvent>().Attach(bonus).Attach(tank).Schedule();
}
private void OnTriggerEnter(Collider other)
{
TriggerEnterEvent.Invoke();
}
protected void ExecuteTriggerEnter()
{
TriggerEnterEvent?.Invoke();
OnTriggerEnterEvent.Invoke();
}
public override void OnEnable()
{
base.OnEnable();
LobbyComponents.OnAdd().Subscribe(entity1 =>
{
var lobbyComponent = entity1.GetComponent <LobbyComponent>();
lobbyComponent.CreateRoomButton.OnPointerClickAsObservable().Subscribe(_ =>
{
NetworkSystem.Publish(RequestCode.CreateRoom, EmptyStr);
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer);
lobbyComponent.RefreshButton.OnPointerClickAsObservable().Subscribe(_ =>
{
NetworkSystem.Publish(RequestCode.ListRooms, EmptyStr);
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer);
UserComponents.OnAdd().Subscribe(entity2 =>
{
var userComponent = entity2.GetComponent <UserComponent>();
if (userComponent.IsLocalPlayer)
{
userComponent.UserName.DistinctUntilChanged().Where(_ => lobbyComponent.UsernameText).Subscribe(name =>
{
lobbyComponent.UsernameText.text = name;
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer).AddTo(userComponent.Disposer);
userComponent.TotalCount.DistinctUntilChanged().Where(_ => lobbyComponent.TotalCountText).Subscribe(count =>
{
lobbyComponent.TotalCountText.text = TotalCount1Str + count;
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer).AddTo(userComponent.Disposer);
userComponent.WinCount.DistinctUntilChanged().Where(_ => lobbyComponent.WinCountText).Subscribe(count =>
{
lobbyComponent.WinCountText.text = WinCount1Str + count;
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer).AddTo(userComponent.Disposer);
}
NetworkSystem.Receive(RequestCode.QuitRoom).Subscribe(data =>
{
if (userComponent.UserId == int.Parse(data.StringValue) && (userComponent.IsLocalPlayer || userComponent.IsRoomOwner.Value))
{
var evt = new TriggerEnterEvent();
evt.Source = LobbyId;
EventSystem.Send(evt);
}
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer).AddTo(userComponent.Disposer);
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer);
NetworkSystem.Receive(RequestCode.CreateRoom).Subscribe(data =>
{
string[] strs = data.StringValue.Split(Separator);
ReturnCode returnCode = (ReturnCode)int.Parse(strs[0]);
if (returnCode == ReturnCode.Success)
{
int userId = int.Parse(strs[1]);
string username = strs[2];
int totalCount = int.Parse(strs[3]);
int winCount = int.Parse(strs[4]);
EventSystem.Send(new SpawnUserEvent(userId, username, totalCount, winCount, true, true));
var evt = new TriggerEnterEvent();
evt.Source = RoomId;
EventSystem.Send(evt);
}
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer);
NetworkSystem.Receive(RequestCode.ListRooms).Subscribe(data =>
{
foreach (var entity3 in RoomItemComponents.Entities)
{
var viewComponent = entity3.GetComponent <ViewComponent>();
Destroy(viewComponent.Transforms[0].gameObject);
}
if (!string.IsNullOrEmpty(data.StringValue))
{
string[] str1s = data.StringValue.Split(VerticalBar);
foreach (var str1 in str1s)
{
string[] str2s = str1.Split(Separator);
PrefabFactory.Instantiate(roomItemPrefab, lobbyComponent.RoomItemRoot, false, go =>
{
var roomItemComponent = go.GetComponent <RoomItemComponent>();
roomItemComponent.UserId = int.Parse(str2s[0]);
roomItemComponent.UsernameText.text = str2s[1];
roomItemComponent.TotalCountText.text = TotalCount2Str + str2s[2];
roomItemComponent.WinCountText.text = WinCount2Str + str2s[3];
});
}
}
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer);
NetworkSystem.Receive(RequestCode.JoinRoom).Subscribe(data =>
{
string[] str1s = data.StringValue.Split(VerticalBar);
ReturnCode returnCode = (ReturnCode)int.Parse(str1s[0]);
if (returnCode == ReturnCode.Success)
{
for (int i = 1; i < str1s.Length; i++)
{
string[] str2s = str1s[i].Split(Separator);
int userId = int.Parse(str2s[0]);
string username = str2s[1];
int totalCount = int.Parse(str2s[2]);
int winCount = int.Parse(str2s[3]);
bool isRoomOwner = bool.Parse(str2s[4]);
EventSystem.Send(new SpawnUserEvent(userId, username, totalCount, winCount, false, isRoomOwner));
}
var evt = new TriggerEnterEvent();
evt.Source = RoomId;
EventSystem.Send(evt);
}
else
{
EventSystem.Send(new MessageEvent(JoinFailFeedback, LogType.Warning));
}
}).AddTo(this.Disposer).AddTo(lobbyComponent.Disposer);
}).AddTo(this.Disposer);
RoomItemComponents.OnAdd().Subscribe(entity =>
{
var roomItemComponent = entity.GetComponent <RoomItemComponent>();
roomItemComponent.JoinButton.OnPointerClickAsObservable().Subscribe(_ =>
{
NetworkSystem.Publish(RequestCode.JoinRoom, roomItemComponent.UserId.ToString());
}).AddTo(this.Disposer).AddTo(roomItemComponent.Disposer);
}).AddTo(this.Disposer);
}
private void OnChildsChanged(IEntity entity, CompositeDisposable childsChangeDisposer, Tweener centeringTweener)
{
var centerOnChild = entity.GetComponent <CenterOnChild>();
var viewComponent = entity.GetComponent <ViewComponent>();
var draggedPositions = new List <Vector3>();
var direction = Vector3.zero;
var delta = Vector3.zero;
if (centerOnChild.Content)
{
childsChangeDisposer.Clear();
for (int i = 0; i < centerOnChild.Content.childCount + 1; i++)
{
var index = i;
var target = index == centerOnChild.Content.childCount ? viewComponent.Transforms[0] : centerOnChild.Content.GetChild(index);
target.OnPointerClickAsObservable().Where(eventData => !eventData.dragging && index < centerOnChild.Content.childCount).Subscribe(eventData =>
{
if (centerOnChild.Index.Value == index)
{
var evt = new TriggerEnterEvent();
evt.Source = target.gameObject;
EventSystem.Send(evt);
}
else
{
centerOnChild.Index.Value = index;
}
}).AddTo(this.Disposer).AddTo(centerOnChild.Disposer).AddTo(childsChangeDisposer);
target.OnBeginDragAsObservable().Where(_ => centeringTweener != null).Subscribe(_ =>
{
centeringTweener.Kill();
centeringTweener = null;
direction = Vector3.zero;
draggedPositions.Clear();
draggedPositions.Add(centerOnChild.Content.position);
}).AddTo(this.Disposer).AddTo(centerOnChild.Disposer).AddTo(childsChangeDisposer);
target.OnDragAsObservable().Subscribe(_ =>
{
draggedPositions.Add(centerOnChild.Content.position);
}).AddTo(this.Disposer).AddTo(centerOnChild.Disposer).AddTo(childsChangeDisposer);
target.OnEndDragAsObservable().Subscribe(_ =>
{
delta = draggedPositions.Count > 1 ? draggedPositions[draggedPositions.Count - 1] - draggedPositions[draggedPositions.Count - 2] : Vector3.zero;
for (int j = draggedPositions.Count - 1; j > 0; j--)
{
direction = Vector3.Normalize(draggedPositions[j] - draggedPositions[j - 1]);
if (direction != Vector3.zero)
{
break;
}
}
centerOnChild.Index.SetValueAndForceNotify(GetBestChild(entity, direction, delta));
}).AddTo(this.Disposer).AddTo(centerOnChild.Disposer).AddTo(childsChangeDisposer);
}
}
}
public void OnTriggerEnter2D(Collider2D collider)
{
TriggerEnterEvent?.Invoke(collider);
}
void OnTriggerEnter(Collider collider)
{
var e = new TriggerEnterEvent(egoComponent, collider.gameObject.GetComponent <EgoComponent>(), collider);
EgoEvents <TriggerEnterEvent> .AddEvent(e);
}
public void Explosion(TriggerEnterEvent e, RemoteTankNode targetTank, SpiderActiveNode spider, [JoinByTank] SingleNode <SelfTankComponent> tank)
{
MineUtil.ExecuteSplashExplosion(spider.Entity, tank.Entity, spider.rigidbody.Rigidbody.transform.position);
}
