protected virtual void PuzzleMoveAnim()
{
float _targetX = MovePos.Value.x / DefineClass.PuzzleXSize;
float _targetY = MovePos.Value.y / DefineClass.PuzzleYSize;
Vector3 targetPos = MovePos.Value;
targetPos.x = x;
targetPos.y += DefineClass.PuzzleYSize;
if (targetPos.y != GetPos().y)
{
Anime.Play(GetPos(), targetPos, Motion.Uniform(DefineClass.PuzzleDropAnimVel * (y - _targetY)))
.SubscribeToLocalPosition(gameObject).AddTo(this);
}
Observable.Interval(TimeSpan.FromSeconds(DefineClass.PuzzleDropAnimVel * (_targetY - y))).First().Subscribe(x =>
{
Anime.Play(GetPos(), MovePos.Value, Motion.Uniform(DefineClass.PuzzleDropAnimVel))
.Subscribe(_ =>
{
transform.localPosition = _;
if (GetPos() == MovePos.Value)
{
PuzzleManager.instance.puzzleArray[y, x] = null;
x = (int)_targetX;
y = (int)_targetY;
PuzzleManager.instance.puzzleArray[y, x] = this;
}
}).AddTo(this);
}).AddTo(this);
}
public void Start()
{
var canvas = GetComponent <CanvasGroup>();
var selectables = new List <Selectable>();
Messenger.Broker.Receive <OnGameStart>()
.Subscribe(_ =>
{
selectables = GetComponentsInChildren <Selectable>().Where(x => x.interactable).ToList();
foreach (var selectable in selectables)
{
selectable.interactable = false;
}
Anime.Play(1.0f, 0.0f, Easing.OutCubic(TimeSpan.FromSeconds(0.3f)))
.Subscribe(x => { canvas.alpha = x; });
})
.AddTo(this);
Messenger.Broker.Receive <OnGameFinish>()
.Subscribe(_ =>
{
Anime.Wait <float>(TimeSpan.FromSeconds(1.0f))
.Play(0.0f, 1.0f, Easing.InCubic(TimeSpan.FromSeconds(0.3f)))
.DoOnCompleted(() =>
{
foreach (var selectable in selectables)
{
selectable.interactable = true;
}
})
.Subscribe(x => { canvas.alpha = x; });
})
.AddTo(this);
}
private IEnumerator Sample12()
{
var hp = new ReactiveProperty <int>(100);
var gauge = new ReactiveProperty <float>(100.0f);
// HPゲージは、実際の値に1.5秒かけて追いつく
hp
.Select(x => Anime.Play(gauge.Value, x, Easing.OutSine(TimeSpan.FromSeconds(1.5))))
.Switch()
.Subscribe(x => gauge.Value = x);
gauge.Subscribe(x =>
{
// HPゲージの長さにする
Debug.LogFormat("hp: {0}", x);
});
yield return(new WaitForSeconds(1.0f));
Debug.Log("ダメージを受けてHPが30に！");
hp.Value = 30;
yield return(new WaitForSeconds(1.0f));
Debug.Log("回復してHPが80に！");
hp.Value = 80;
}
public void Start()
{
Messenger.Broker.Receive <OnRefrectBall>().Select(_ => Anime.Play(big, Vector3.one, Easing.OutElastic(TimeSpan.FromSeconds(0.5f))))
.TakeUntilDestroy(gameObject)
.Switch()
.SubscribeToLocalScale(transform);
}
private void Sample9()
{
var leftCube1 = Anime
.Play(new Vector3(-5f, 0f, 0f), new Vector3(-0.5f, 0f, 0f), Easing.Linear(TimeSpan.FromSeconds(2.5f)))
.DoToPosition(cube);
var rightCube1 = Anime
.Play(new Vector3(5f, 0f, 0f), new Vector3(0.5f, 0f, 0f), Easing.OutCubic(TimeSpan.FromSeconds(1f)))
.DoToPosition(cube2);
var leftCube2 = Anime
.Play(new Vector3(-0.5f, 0f, 0f), new Vector3(-0.5f, 3f, 0f),
Easing.OutCubic(TimeSpan.FromSeconds(1f)))
.DoToPosition(cube);
var rightCube2 = Anime
.Play(new Vector3(0.5f, 0f, 0f), new Vector3(0.5f, 3f, 0f),
Easing.OutCubic(TimeSpan.FromSeconds(1f)))
.DoToPosition(cube2);
Observable.WhenAll(leftCube1, rightCube1)
.ContinueWith(Observable.WhenAll(leftCube2, rightCube2))
.StopRecording()
.Subscribe();
}
private void Sample8()
{
Anime.Play(0f, Mathf.PI * 2f, Easing.OutCubic(TimeSpan.FromSeconds(3f)))
.Select(x => new Vector3(Mathf.Sin(x), Mathf.Cos(x), 0.0f))
.Select(x => x * 3f)
.StopRecording()
.SubscribeToPosition(cube);
}
private void Sample7()
{
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(5f, 0f, 0f),
Easing.InOutSine(TimeSpan.FromSeconds(1f)))
.Play(new Vector3(-5f, 0f, 0f), Easing.InOutSine(TimeSpan.FromSeconds(1f)))
.Repeat()
.SubscribeToPosition(cube);
}
public void Sample2()
{
var cube1 = CreatePrimitiveCube();
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(5f, 0f, 0f), Easing.InOutQuad(TimeSpan.FromSeconds(3f)))
.SubscribeToPosition(cube1)
.AddTo(cube1);
}
private void Sample10()
{
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(0f, 0f, 0f), Easing.OutExpo(TimeSpan.FromSeconds(2f)))
.Wait(TimeSpan.FromSeconds(1f))
.Play(new Vector3(5f, 0f, 0f), Easing.OutExpo(TimeSpan.FromSeconds(2f)))
.StopRecording()
.SubscribeToPosition(cube);
}
public void Sample1()
{
var cube1 = CreatePrimitiveCube();
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(5f, 0f, 0f), Motion.Uniform(5f))
.SubscribeToPosition(cube1)
.AddTo(cube1);
}
private void Sample10()
{
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(0f, 0f, 0f), Easing.OutExpo(2f))
.Sleep(1f)
.Play(new Vector3(5f, 0f, 0f), Easing.OutExpo(2f))
.StopRecording()
.SubscribeToPosition(cube);
}
public void Start()
{
subject.Select(_ => Anime
.Play(new Vector3(0.8f, 0.6f, 1f), new Vector3(0.8f, 0.6f, 1f), Easing.Linear(anime1))
.Play(new Vector3(1.5f, 1.5f, 1f), new Vector3(1f, 1f, 1f), Easing.OutElastic(TimeSpan.FromSeconds(0.5f))))
.Switch()
.SubscribeToLocalScale(sprite.transform)
.AddTo(this);
}
private void Sample2()
{
var animator = Motion.Uniform(5f);
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(5f, 0f, 0f), animator)
.Play(new Vector3(0f, 3f, 0f), animator)
.StopRecording()
.SubscribeToPosition(cube);
}
private void Shuffle()
{
var shuffleX = Anime.Play(-1f, 1f, new ShuffleAnimator(3f));
var shuffleY = Anime.Play(-1f, 1f, new ShuffleAnimator(3f));
Observable.CombineLatest(shuffleX, shuffleY)
.Select(x => new Vector3(x[0], x[1]))
.SubscribeToPosition(cube);
}
public void Sample3()
{
var cube1 = CreatePrimitiveCube();
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(0f, 0f, 0f), Easing.OutExpo(2f))
.Sleep(0.5f)
.Play(new Vector3(5f, 0f, 0f), Easing.OutExpo(2f))
.SubscribeToPosition(cube1)
.AddTo(cube1);
}
public void Sample3()
{
var cube1 = CreatePrimitiveCube();
Anime.Play(new Vector3(-5f, 0f, 0f), new Vector3(0f, 0f, 0f), Easing.OutExpo(TimeSpan.FromSeconds(2f)))
.Stop(TimeSpan.FromSeconds(0.5f))
.Play(new Vector3(5f, 0f, 0f), Easing.OutExpo(TimeSpan.FromSeconds(2f)))
.SubscribeToPosition(cube1)
.AddTo(cube1);
}
private async UniTask CircleTestElement(Component go, float delay)
{
await Anime.Delay(delay);
await Anime.Play(
Animator.Convert(Easing.Create <OutCubic>(0.0f, Mathf.PI * 2.0f, 2f),
x => new Vector3(Mathf.Sin(x), Mathf.Cos(x), 0.0f) * 3.0f),
TranslateTo.LocalPosition(go)
);
}
private async UniTask LineTestElement()
{
const byte colorA = 64;
/*
* var colors = new[]
* {
* // 114
* new Color32(78, 191, 214, colorA),
* new Color32(0, 85, 149, colorA),
* new Color32(25, 36, 74, colorA),
* new Color32(87, 189, 168, colorA),
* new Color32(246, 249, 228, colorA),
* new Color32(0, 0, 0, colorA),
* new Color32(162, 67, 137, colorA),
* new Color32(229, 230, 71, colorA),
* };
*/
var colors = new[]
{
new Color32(255, 0, 0, colorA),
new Color32(0, 255, 0, colorA),
new Color32(0, 0, 255, colorA),
new Color32(255, 255, 0, colorA),
new Color32(255, 0, 255, colorA),
new Color32(0, 255, 255, colorA),
};
var unitCircle = Random.insideUnitCircle.normalized * Random.Range(2f, 8f);
using (var shapeObject = new DisposableGameObject(
new Vector3(unitCircle.x, unitCircle.y, 50f)
))
{
var shape = shapeObject.AddComponent <Line>();
shape.Geometry = LineGeometry.Volumetric3D;
shape.BlendMode = ShapesBlendMode.Additive;
shape.Color = colors[Random.Range(0, colors.Length)];
shape.Start = new Vector3(0f, 0f, 0f);
shape.End = new Vector3(0f, 0f, Random.Range(4f, 10f));
shape.Thickness = Random.Range(0.1f, 1.0f);
await UniTask.WhenAll(
Anime.PlayTo(
Easing.Create <OutCubic>(-20f, Random.Range(1f, 3f)),
TranslateTo.LocalPositionZ(shape)
),
Anime.Play(
Easing.Create <InCubic>(Vector3.zero, Vector3.one, 0.15f),
TranslateTo.LocalScale(shape)
)
);
}
}
public void Sample21()
{
var x = Anime.Play(1.0f, 0.5f, Easing.InOutSine(TimeSpan.FromSeconds(1f)))
.Play(1.0f, Easing.OutElastic(TimeSpan.FromSeconds(0.8f)));
var y = Anime.Play(1.0f, 1.2f, Easing.InOutSine(TimeSpan.FromSeconds(1f)))
.Play(1.0f, Easing.OutElastic(TimeSpan.FromSeconds(0.8f)));
Observable.CombineLatest(x, y)
.Select(s => new Vector3(s[0], s[1], 1f))
.SubscribeToLocalScale(sphere);
}
public void Sample7()
{
var cube1 = CreatePrimitiveCube();
Observable.CombineLatest(
Anime.Play(0, 0.5f, Motion.Random(TimeSpan.FromSeconds(2f), -1f, 1f)),
Anime.Play(0, 0.5f, Motion.Random(TimeSpan.FromSeconds(2f), -1f, 1f)),
Anime.Stay(0f)
)
.SubscribeToPosition(cube1)
.AddTo(cube1);
}
private async Task CircleAnimation(GameObject go, float delay)
{
await Anime.Delay(delay);
await Anime.Play(
Easing.Create <OutCubic>(0.0f, Mathf.PI * 2.0f, 2f),
TranslateTo.Action <float>(x =>
{
var p = new Vector3(Mathf.Sin(x), Mathf.Cos(x), 0.0f) * 3.0f;
go.transform.localPosition = p;
}));
}
protected virtual void PuzzleChangeAnim(PuzzleBaseItemObj _target)
{
Anime.Play(transform.localPosition, _target.GetPos(), Motion.Uniform(DefineClass.PuzzleItemChangeAnimVel))
.Subscribe(_ =>
{
transform.localPosition = _;
if (transform.localPosition == _target.transform.localPosition)
{
PuzzleManager.instance.DestroyPuzzleItem();
}
});
}
public virtual void DestroyPuzzleItem()
{
Anime.Play(transform.localScale, DefineClass.Vector3Zero, Motion.Uniform(DefineClass.PuzzleItemDestroyAnimVel))
.Subscribe(_ =>
{
transform.localScale = _;
if (transform.localScale == DefineClass.Vector3Zero)
{
PuzzleManager.instance.puzzleArray[y, x] = null;
PoolManager.instance.puzzlePool.Return(this);
}
});
}
private void Sample5()
{
var x = Anime.Play(-5f, 5f, Easing.InOutSine(TimeSpan.FromSeconds(3f)));
var y = Anime.Play(0f, 3f, Easing.InOutSine(TimeSpan.FromSeconds(1.5f)))
.Play(0f, Easing.InOutSine(TimeSpan.FromSeconds(1.5f)));
var z = Anime.Stay(0f);
Observable.CombineLatest(x, y, z)
.StopRecording()
.SubscribeToPosition(cube);
}
void CreateQuestion()
{
int optionsCount = Mathf.Min(Random.Range(2, 5), restPrefectureIndexes.Count);
float span = 200f;
float left = (optionsCount - 1) * -span * 0.5f;
var tempList = new List <int>(restPrefectureIndexes);
List <int> options = new List <int>();
for (int i = 0; i < optionsCount; i++)
{
int pick = Random.Range(0, tempList.Count);
options.Add(tempList[pick]);
tempList.RemoveAt(pick);
}
question = options[Random.Range(0, options.Count)];
// Debug.Log(question);
questionText.text = prefectures[question];
optionInstances = new List <GameObject>();
for (var i = 0; i < options.Count; i++)
{
GameObject go = CreateCard(options[i]);
optionInstances.Add(go);
go.SetActive(false);
Vector3 scale = go.transform.localScale;
Observable
.Return(i)
.Delay(System.TimeSpan.FromSeconds(Random.Range(0f, 0.5f)))
.Subscribe(index =>
{
go.SetActive(true);
Anime.Play(
startPos,
new Vector3(left + span * index, 0f, 0f),
Easing.InExpo(System.TimeSpan.FromSeconds(1.0f))
).SubscribeToLocalPosition(go);
Anime.Play(
scale * 0.01f,
scale,
Easing.InExpo(System.TimeSpan.FromSeconds(1.0f))
).SubscribeToLocalScale(go);
}
);
}
}
private void Sample17()
{
var flow = Anime.Play(Easing.InOutExpo(TimeSpan.FromSeconds(2.5f)))
.Wait(TimeSpan.FromSeconds(0.5f))
.Play(1.0f, 0.0f, Easing.InOutExpo(TimeSpan.FromSeconds(2.5f)));
flow
.Lerp(new Vector3(-5f, 0f, 0f), new Vector3(5f, 0f, 0f))
.SubscribeToPosition(cube);
flow
.Range(0.0f, 0.5f)
.Lerp(new Vector3(-5f, -1f, 0f), new Vector3(0f, -1f, 0f))
.SubscribeToPosition(cube2);
}
public void Sample4()
{
var cube1 = CreatePrimitiveCube();
var x = Anime.Play(-5f, 5f, Easing.InOutSine(TimeSpan.FromSeconds(3f)));
var y = Anime.Play(0f, -3f, Easing.InOutSine(TimeSpan.FromSeconds(1.5f)))
.Play(0f, Easing.InOutSine(TimeSpan.FromSeconds(1.5f)));
var z = Anime.Stay(0f);
Observable.CombineLatest(x, y, z)
.SubscribeToPosition(cube1)
.AddTo(cube1);
}
private void StartAnimation(int newIndex)
{
_currentAnimation?.Dispose();
var curPos = offScreenCamera.transform.position;
var nextPos = _characters[newIndex].transform.position;
var animator = Easing.InOutCubic(showTime);
_currentAnimation = Anime.Play(curPos, nextPos, animator)
.Subscribe(
p => offScreenCamera.transform.position = new Vector3(p.x, curPos.y, curPos.z),
onCompleted: () => _currentCharacterIndex = newIndex)
.AddTo(this);
}
public void Sample20()
{
var circle = Anime
.Play(Mathf.PI, Mathf.PI * 2f * 3f, Easing.InOutSine(TimeSpan.FromSeconds(3f)))
.Select(x => new Vector3(Mathf.Sin(x), Mathf.Cos(x), 0f));
var straight = Anime
.Play(-3f, 3f, Easing.InOutSine(TimeSpan.FromSeconds(3f)))
.Select(x => new Vector3(0f, x, 0f));
Observable.CombineLatest(circle, straight)
.Sum()
.StopRecording()
.SubscribeToPosition(cube);
}
private void Sample4()
{
var positions = new[]
{
new Vector3(-5f, 0f, 0f),
new Vector3(0f, 3f, 0f),
new Vector3(5f, 0f, 0f),
new Vector3(0f, -3f, 0f),
new Vector3(-5f, 0f, 0f),
};
Anime.Play(positions, Easing.InOutSine(TimeSpan.FromSeconds(6f)))
.StopRecording()
.SubscribeToPosition(cube);
}
