private void Start()
{
signalBus.GetStream <GameEndSignal>()
.TakeUntilDestroy(this)
.Subscribe(_ => locked = true);
signalBus.GetStream <GoalScoredSignal>()
.TakeUntilDestroy(this)
.TakeUntil(signalBus.GetStream <GameEndSignal>())
.Subscribe(_ => locked = true);
signalBus.GetStream <BallResetSignal>()
.TakeUntilDestroy(this)
.TakeUntil(signalBus.GetStream <GameEndSignal>())
.Subscribe(_ => locked = false);
gameObject.OnTriggerEnter2DAsObservable()
.TakeUntilDestroy(this)
.Where(_ => !locked)
.Where(collision => collision.gameObject == ball.gameObject)
.Select(_ => teamsData.teams.FirstOrDefault(element => element.id != team).id)
.Subscribe(scoringTeamId => signalBus.Fire(new GoalScoredSignal()
{
team = scoringTeamId
}));
if (teamsData.teams.Length > 0)
{
Color color = teamsData.teams.First(element => element.id == team).color;
color.a = .5f;
GetComponent <Renderer>().material.color = color;
}
}
private void Start()
{
signalBus.GetStream <PlayerKilledSignal>()
.TakeUntilDestroy(this)
.Subscribe(_ => signalBus.Fire(new RumbleTriggeredSignal {
magnitude = 3f
}));
float currentRumble = 0;
float maxRumbleMagnitude = .05f;
float rumbleFrquency = 60;// in rotations per second
Observable.EveryUpdate()
.TakeUntilDestroy(this)
.Subscribe(__ => currentRumble = Mathf.Lerp(currentRumble, 0, 5 * Time.deltaTime));
Observable.EveryUpdate()
.TakeUntilDestroy(this)
.Subscribe(__ =>
{
rumbledTransform.localPosition = new Vector2(Mathf.Cos(Time.time * rumbleFrquency), Mathf.Sin(Time.time * rumbleFrquency) * 3) * currentRumble;
});
signalBus.GetStream <RumbleTriggeredSignal>()
.TakeUntilDestroy(this)
.Subscribe(signal => currentRumble = Mathf.Min(maxRumbleMagnitude, signal.magnitude + maxRumbleMagnitude));
}
void Start()
{
_slider.maxValue = (float)_simulationData.MaxTime;
_slider.minValue = 0;
_signalBus.GetStream <CarleyCorpSignal>()
.Where(x => x.CarleyCorpEvent == CarleyCorpEvent.Manual)
.Subscribe(x =>
{
_slider.interactable = true;
Reset();
})
.AddTo(gameObject);
_signalBus.GetStream <CarleyCorpSignal>()
.Where(x => x.CarleyCorpEvent != CarleyCorpEvent.Manual && x.CarleyCorpEvent != CarleyCorpEvent.Reset && x.CarleyCorpEvent != CarleyCorpEvent.Play)
.Subscribe(x =>
{
_slider.interactable = false;
Reset();
})
.AddTo(gameObject);
_signalBus.GetStream <CarleyCorpSignal>()
.Where(x => x.CarleyCorpEvent == CarleyCorpEvent.Reset && _simulationData.SimulationType == SimulationData.SimulationSystem.Manual && x.CarleyCorpEvent != CarleyCorpEvent.Play)
.Subscribe(x =>
{
Reset();
})
.AddTo(gameObject);
}
public void Initialize()
{
_signalBus.GetStream <SignalShotSpawn>()
.Subscribe(x => Create(x.Position, x.Forward)).AddTo(_disposables);
_signalBus.GetStream <SignalShotDestroy>()
.Subscribe(x => Destroy(x.OneView)).AddTo(_disposables);
}
public override void Initialize()
{
_signalBus.GetStream <SignalPlayerCreated>()
.Subscribe(x => OnPlayerCreated(x.Entity)).AddTo(_disposables);
_signalBus.GetStream <SignalShotSpawn>()
.Subscribe(x => OnShotSpawn(x.FireRate)).AddTo(_disposables);
_signalBus.GetStream <SignalWeaponSwitch>()
.Subscribe(x => OnWeaponSwitch(x.WeaponType)).AddTo(_disposables);
}
public void Start()
{
var rigidBody = GetComponent <Rigidbody2D>();
var collider = GetComponent <Collider2D>();
gameCameraState.pointsOfInterest.Add(transform);
gameObject.OnDestroyAsObservable()
.First()
.Subscribe(_ => gameCameraState.pointsOfInterest.Remove(transform));
signalBus.GetStream <GoalScoredSignal>()
.TakeUntilDestroy(this)
.Subscribe(_ =>
{
Instantiate(goalExplosion, transform.position, transform.rotation).AutoDestruct();
ProjectUtils.AddExplosionForce(1000, transform.position, 20, explosionMask.value);
gameObject.SetActive(false);
gameCameraState.pointsOfInterest.Add(resetPoint);
Observable.Timer(TimeSpan.FromSeconds(5))
.TakeUntilDestroy(this)
.Subscribe(__ =>
{
gameObject.SetActive(true);
gameCameraState.pointsOfInterest.Remove(resetPoint);
Reset();
});
});
// Add the toggling of the slowdown effect
bool slowingEffectActive = true;
signalBus.GetStream <GoalScoredSignal>()
.Select(_ => true)
.Merge(signalBus.GetStream <BallResetSignal>().Select(_ => false))
.TakeUntilDestroy(this)
.Subscribe(isBetweenScoreAndReset => slowingEffectActive = !isBetweenScoreAndReset);
// Init the slowdown effect
Observable.EveryUpdate()
.TakeUntilDestroy(this)
.Where(_ => slowingEffectActive)
.Select(_ => Physics2D.CircleCast(transform.position, collider.bounds.extents.x, rigidBody.velocity, rigidBody.velocity.magnitude, pathCastingMask.value))
.Where(hit => hit.collider != null)
// HACK
.Where(hit => hit.collider.gameObject.GetComponent <Goal>() != null)
.Subscribe(hit => signalBus.Fire(new TimeSlowSignal {
slowTime = .1f
}));
Reset();
}
public void Construct(Cow.Factory cowFactory, SignalBus signalBus)
{
_cowFactory = cowFactory;
_signalBus = signalBus;
_signalBus.GetStream <GameOver>()
.Subscribe(x => DestroyAllCows())
.AddTo(_disposables);
_signalBus.GetStream <GameRestart>()
.Subscribe(x => Restart())
.AddTo(_disposables);
StartCoroutine(CreatFirstCows());
}
public override void EnterState()
{
base.EnterState();
// Instantiate the Feature Points
m_trackBuilder.InstantiateFeaturePoints(ref m_buildSM.CurrentTrackData.m_featurePoints);
OnTrackChanged();
m_trackChangedSubscription = m_signalBus
.GetStream <FeaturePointChanged> ()
.Select(_ => new Unit())
.Merge(m_signalBus.GetStream <SettingsChangedSignal>().Select(_ => new Unit()))
.Throttle(TimeSpan.FromSeconds(1))
.Subscribe(_ => OnTrackChanged());
}
public void Initialize()
{
Observable.EveryUpdate()
.Where(_ => InputManager.ActiveDevice.CommandWasPressed || Input.GetKeyDown(KeyCode.Escape))
.Subscribe(_ => state.isPaused.Value = !state.isPaused.Value)
.AddTo(disposables);
float goalTimeScale = 1f;
float endSlowdownTime = 0f;
state.isPaused
.Subscribe(_ => Time.timeScale = goalTimeScale)
.AddTo(disposables);
Observable.EveryUpdate()
.Select(_ => (state.isPaused.Value) ? 0 : Mathf.SmoothStep(Time.timeScale, (Time.time < endSlowdownTime) ? goalTimeScale : 1, 8 * Time.deltaTime))
.Subscribe(timeScale => {
gameMixer.SetFloat("GamePitch", timeScale);
Time.timeScale = timeScale;
})
.AddTo(disposables);
signalBus.GetStream <TimeSlowSignal>()
.Subscribe(signal => {
goalTimeScale = .4f;
endSlowdownTime = Time.time + signal.slowTime;
})
.AddTo(disposables);
Observable.EveryUpdate()
.Where(_ => Input.GetKeyDown(KeyCode.T))
.Subscribe(_ => signalBus.Fire(new TimeSlowSignal {
slowTime = 2f
}))
.AddTo(disposables);
}
private void Initialize(SignalBus signalBus)
{
signalBus
.GetStream <SeasonText>()
.Subscribe(x => TextMeshProUGUI.SetText(x.Title))
.AddTo(gameObject);
}
private void Initialize(SignalBus signalBus)
{
signalBus
.GetStream <SeasonColor>()
.Select(x => x.Color)
.Subscribe(TransitColor)
.AddTo(gameObject);
}
private void Initialize(SignalBus signalBus)
{
signalBus
.GetStream <SeasonText>()
.Select(x => x.Body)
.Subscribe(RenderTextAsTypeWriter)
.AddTo(gameObject);
}
private void Start()
{
gameState.isPaused
.TakeUntilDestroy(this)
.Subscribe(isPaused => root.SetActive(!isPaused));
signalBus.GetStream <GoalScoredSignal>()
.TakeUntilDestroy(this)
.Subscribe(_ => {
centerTextUI.text = "Goal!";
centerTextUI.enabled = true;
Observable.Timer(TimeSpan.FromSeconds(5))
.TakeUntilDestroy(this)
.TakeUntil(signalBus.GetStream <GameEndSignal>())
.Subscribe(__ => centerTextUI.enabled = false);
Observable.Interval(TimeSpan.FromSeconds(1))
.TakeUntilDestroy(this)
.TakeUntil(signalBus.GetStream <GameEndSignal>())
.TakeWhile(interval => interval <= 5)
.Skip(1)
.Subscribe(interval => centerTextUI.text = (4 - interval).ToString());
});
signalBus.GetStream <GameEndSignal>()
.TakeUntilDestroy(this)
.Subscribe(_ => {
var winningTeam = teamsData.teams.First(selectedTeam => selectedTeam.id == soccerState.scores.MaxValueOrDefault(score => score.Value).Key);
centerTextUI.text = winningTeam.displayName + " wins!";
centerTextUI.enabled = true;
});
soccerState.scores.ObserveReplace()
.TakeUntilDestroy(this)
.Subscribe(_ =>
{
string scoreText = string.Empty;
foreach (int teamId in soccerState.scores.Keys)
{
var team = teamsData.teams.FirstOrDefault(selectedTeam => selectedTeam.id == teamId);
scoreText += team.name + ": " + soccerState.scores[teamId] + " - ";
}
scoreTextUI.text = scoreText;
});
soccerState.secondsRemaining
.TakeUntilDestroy(this)
.Subscribe(remainingTime => timerTextUI.text = remainingTime.ToString());
}
public void Initialize()
{
Observable.EveryUpdate()
.Where(_ => Input.GetKeyDown(KeyCode.W))
.Subscribe(_ => signalBus.Fire <LevelWonSignal>())
.AddTo(disposables);
Observable.EveryUpdate()
.Where(_ => Input.GetKeyDown(KeyCode.L))
.Subscribe(_ => signalBus.Fire <LevelLostSignal>())
.AddTo(disposables);
signalBus.GetStream <LevelWonSignal>()
.Subscribe(_ => levelsController.LaunchNextLevel())
.AddTo(disposables); //go to next level
signalBus.GetStream <LevelLostSignal>()
.Subscribe(_ => levelsController.RestartLevel())
.AddTo(disposables); //reload the level
spawnPointGroup.SpawnPlayerAtStart(playerData[0]);
}
public void Initialize()
{
var jointBreakStream = signalBus.GetStream <JointBrokenSignal>();
jointBreakStream.Buffer(jointBreakStream.Throttle(TimeSpan.FromSeconds(.2)))
.Where(xs => xs.Count >= 3)
.Subscribe(xs => signalBus.Fire(new TimeSlowSignal {
slowTime = 2f
}))
.AddTo(disposables);
}
public void Initialize()
{
//_signalBus.Subscribe<PanelOpenSignal>(OpenPanel);
//_signalBus.Subscribe<PanelCloseSignal>(OnPanelCloseSignal);
_signalBus.GetStream <PanelOpenSignal>()
.SubscribeOn(Scheduler.ThreadPool)
.ObserveOnMainThread()
.Subscribe((s) => OpenPanel(s));
_signalBus.GetStream <PanelCloseSignal>()
.SubscribeOn(Scheduler.ThreadPool)
.ObserveOnMainThread()
.Subscribe((s) => OnPanelCloseSignal(s));
_panels = new ConcurrentDictionary <string, VehicleDetailsPanelView>();
_scoreLabel.text = "Panels: 0";
// _vehicles3D = new Directory<Vehicle3D>();
// _vehicles3D.Initialize();
}
public void Construct(SignalBus signalBus)
{
Debug.Log("Score ui is injected");
_signalBus = signalBus;
_signalBus.GetStream <IncreaseScoreSignal>()
.Subscribe(x =>
{
currentScore += x.score;
textField.text = currentScore.ToString();
})
.AddTo(_disposables);
}
void Start()
{
//string filepath = @"Assets/StreamingAssets/Json/vehicle_list_full.json";
//_service.path = filepath;
_buttons = new List <VehicleButtonView>();
_service.GetVehicles().Subscribe(x => OnGetVehicle(x));
_signalBus.GetStream <SearchTextSignal>()
.SubscribeOn(Scheduler.ThreadPool)
.ObserveOnMainThread()
.Subscribe((s) => OnSearchTextSignal(s.Text));
}
public override void EnterState()
{
base.EnterState();
Debug.Log("BuildObserveState entered!");
m_subscriptions = new CompositeDisposable();
// clear existing feature points
m_featurePointsManager.ClearFeaturePoints();
IObservable <TrackData> observable;
if (m_observeDialogUI.DoReceiveLiveUpdates)
{
observable = m_useCase.ObserveTrack(m_observeDialogUI.KeyToDownload);
}
else
{
observable = m_useCase.GetTrack(m_observeDialogUI.KeyToDownload);
}
// update session and rebuild track when an update from the server was received
m_subscriptions.Add(observable
.SubscribeOn(Scheduler.ThreadPool)
.ObserveOnMainThread()
.Subscribe(
UpdateTrack,
e => { m_dialogBuilderFactory.Create().MakeGenericExceptionDialog(e); },
() => { }));
// rebuild track if the track move tool was used
m_subscriptions.Add(m_signalBus.GetStream <FeaturePointChanged>()
.SubscribeOn(Scheduler.ThreadPool)
.ObserveOnMainThread()
.Subscribe(
_ => RebuildTrack(),
e => { m_dialogBuilderFactory.Create().MakeGenericExceptionDialog(e); },
() => { }));
}
public void Initialize()
{
/*
* _signalBus.GetStream<PanelOpenSignal>()
* .SubscribeOn(Scheduler.ThreadPool)
* .ObserveOnMainThread()
* .Subscribe((s) => OpenPanel(s));
*
* _signalBus.GetStream<PanelCloseSignal>()
* .SubscribeOn(Scheduler.ThreadPool)
* .ObserveOnMainThread()
* .Subscribe((s) => OnPanelCloseSignal(s));
*/
_signalBus.GetStream <SearchTextSignal>()
.SubscribeOn(Scheduler.ThreadPool)
.ObserveOnMainThread()
.Subscribe((s) => OnSearchTextSignal(s.Text));
_vehicles3D = new Directory <Vehicle3D>();
_vehicles3D.Initialize();
}
private void Start()
{
signalBus.GetStream <SuicideSignal>()
.TakeUntilDestroy(this)
.Subscribe(__ => BreakEffect(true));
}
private void Start()
{
signalBus.GetStream <GrapplingFiredSignal>()
.TakeUntilDestroy(this)
.Where(_ => characterState.localPlayerControl.Value)
.Subscribe(_ =>
{
DestroyRope();
var hit = Physics2D.Raycast(transform.position, characterState.aimDirection.Value, settings.grapplingDistance, settings.grapplingMask.value);
if (hit.transform != null)
{
soundPlayer.PlaySound("Grappling", transform);
Vector3 hitPosition = hit.point;
float distance = Vector2.Distance(hitPosition, transform.position);
float time = distance / settings.grapplingHookSpeed;
var ropeEffect = container.InstantiateComponent <RopeEffect>(gameObject);
currentRope.Add(ropeEffect.Init(transform, hitPosition));
currentRope.Add(ropeEffect);
Observable.Timer(TimeSpan.FromSeconds(time))
.TakeUntil(signalBus.GetStream <GrapplingReleasedSignal>())
.TakeUntilDestroy(this)
.Subscribe(__ =>
{
soundPlayer.PlaySound("Grappled", hitPosition);
var anchor = new GameObject("GrapplingAnchor");
anchor.transform.position = hitPosition;
/*gameCameraState.pointsOfInterest.Add(anchor.transform);
* anchor.OnDestroyAsObservable()
* .Merge(gameObject.OnDestroyAsObservable())
* .Merge(characterState.isCorpse.Where(isCorpse => isCorpse).Select(__ => Unit.Default))
* .First()
* .Subscribe(__ => gameCameraState.pointsOfInterest.Remove(anchor.transform));*/
var anchorRigidbody = anchor.AddComponent <Rigidbody2D>();
anchorRigidbody.isKinematic = true;
var joint = anchor.gameObject.AddComponent <SpringJoint2D>();
joint.autoConfigureDistance = false;
joint.autoConfigureConnectedAnchor = false;
joint.anchor = anchor.transform.InverseTransformPoint(hitPosition);
joint.distance = Vector2.Distance(hitPosition, transform.position) * settings.initialGrapplingDistanceRatio;
joint.dampingRatio = 1f;
joint.frequency = settings.ropeSpringFrequency;
joint.enableCollision = true;
var rigidbody = GetComponent <Rigidbody2D>();
joint.connectedBody = rigidbody;
currentRope.Add(anchor.gameObject);
var climbSoundDisposable = soundPlayer.PlaySound("Climbing", transform);
var endStream = this.OnDestroyAsObservable()
.Merge(anchor.OnDestroyAsObservable())
.Merge(signalBus.GetStream <GrapplingReleasedSignal>().Select(___ => Unit.Default));
endStream
.First()
.Subscribe(___ => climbSoundDisposable.Dispose());
// Add Climbing
Observable.EveryUpdate()
.TakeUntil(endStream)
.Where(___ => characterState.localPlayerControl.Value)
.Select(___ => characterState.aimDirection.Value)
.Subscribe(direction =>
{
var ropeDirection = (anchor.transform.position - transform.position).normalized;
var aimDirection = characterState.aimDirection.Value.normalized;
var ropeDot = Vector2.Dot(aimDirection, ropeDirection);
var left = Vector2.Perpendicular(ropeDirection);
rigidbody.AddForce(settings.swingForce * left * Vector2.Dot(left, aimDirection));
var right = -Vector2.Perpendicular(ropeDirection);
rigidbody.AddForce(settings.swingForce * right * Vector2.Dot(right, aimDirection));
var distanceDelta = ropeDot * settings.ropeClimbSpeed * Time.deltaTime;
joint.distance -= distanceDelta;
if (joint.distance < .1f)
{
joint.frequency += distanceDelta * .5f;
}
});
});
}
});
signalBus.GetStream <GrapplingReleasedSignal>()
.TakeUntilDestroy(this)
.Where(_ => currentRope != null)
.Subscribe(_ => DestroyRope());
}
public void Initialize()
{
_signalBus.GetStream <SignalPlayerSpawn>()
.Subscribe(x => Create(x.Position, x.Forward)).AddTo(_disposables);
}
public override void Initialize()
{
_signalBus.GetStream <SignalPlayerCreated>()
.Subscribe(x => OnPlayerCreated(x.Entity)).AddTo(_disposables);
}
