//reset cloud variables on player death
public void DeathReset()
{
indicatorRenderer.enabled = false;
cloudCollider.enabled = false;
_cloudTimer = LifeTime;
_cloudState = CloudState.Ready;
}
public void DeathReset()
{
cloudRenderer.enabled = false;
cloudCollider.enabled = false;
_timer = cloudTimer;
_cloudState = CloudState.Ready;
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// 雲が隕石で消える一連の動き
/// </summary>
void CloudMeteoriteDestroy()
{
//隕石の回転
Meteorite.transform.Rotate(Vector3.up);
//表示するテキストを変更
if (!m_textChanged)
{
TextChange();
}
//テキスト移動開始までは隕石が移動
if (!m_fallDownMeteorite)
{
MeteoritePosition = Meteorite.transform.position;
MeteoritePosition.y -= SPEED * Time.deltaTime;
Meteorite.transform.position = MeteoritePosition;
//隕石が雲の位置に着くと雲が消える
if (Meteorite.transform.position.y <= CloudObject.transform.position.y)
{
m_cloudState = CloudState.Play;
}
//隕石が停止位置に着くと初期位置に戻りテキストの移動を始める
if (Meteorite.transform.position.y <= TextStopPositionObject.transform.position.y)
{
Meteorite.transform.position = MeteoriteStartPositionObject.transform.position;
m_fallDownMeteorite = true;
}
}
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// 雲がジェットで消える一連の動き
/// </summary>
void CloudJetDestroy()
{
if (!m_textChanged)
{
TextChange();
}
if (!m_leftCharacterMoved)
{
//左側のキャラクターの動き
LeftCharacterPosition = LeftCharacter.transform.position;
LeftCharacterPosition.z += Time.deltaTime * SPEED;
LeftCharacter.transform.position = LeftCharacterPosition;
//雲の右端で雲が動き始める
if (LeftCharacterPosition.z >= CloudRightEndObject.transform.position.z)
{
m_cloudState = CloudState.Play;
}
//画面外へ着くと初期位置へ戻す
if (LeftCharacterPosition.z >= DisplayOutsideObject.transform.position.z)
{
m_leftCharacterMoved = true;
LeftCharacter.transform.position = LeftCharacterStartPositionObject.transform.position;
}
}
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// テキストの動き
/// </summary>
void TextMoving()
{
//テキストが下に下がっていく
CreditText[m_textNum].transform.position = Vector3.MoveTowards(CreditText[m_textNum].transform.position,
TextStopPositionObject.transform.position, Time.deltaTime * m_textSpeed);
//停止位置に着くとリセットする
if (CreditText[m_textNum].transform.position.y <= TextStopPositionObject.transform.position.y)
{
switch (m_cloudDestroyCause)
{
case CloudDestroyCause.Jet:
m_leftCharacterMoved = false;
break;
case CloudDestroyCause.Meteorite:
m_fallDownMeteorite = false;
break;
case CloudDestroyCause.Thunder:
m_thunderTime = 0;
m_thunderFlashCount = 0;
m_lightningStruck = false;
break;
}
m_cloudState = CloudState.Non;
m_cloudDestroyCause = CloudDestroyCause.Non;
m_textChanged = false;
m_textMoving = false;
if (m_textNum == MAX_TEXT_NUM)
{
m_ending = true;
}
}
}
void Start()
{
rain = transform.GetChild(0).GetComponent <ParticleSystem>();
anim = GetComponent <Animator>();
targetBird = GameObject.FindGameObjectWithTag("Player").transform;
anim.SetFloat(State, 0);
cloudState = CloudState.IDLE;
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// 雲が雷で消える一連の動き
/// </summary>
void CloudThunderDestroy()
{
m_thunderTime++;
//表示するテキストを変更
if (!m_textChanged)
{
TextChange();
}
if (!m_lightningStruck)
{
//雷が落ちるまで点滅する
if (m_thunderFlashCount < THUNDER_FLASH_COUNT_LIMIT)
{
if (m_thunderTime % THUNDER_FLASH_INTERVAL == 0 && m_thunderFlashCount % THUNDER_TWICE == 0)
{
ThunderFlash.SetActive(true);
m_thunderFlashCount++;
}
if (m_thunderTime % (THUNDER_FLASH_INTERVAL * THUNDER_TWICE) == 0 && m_thunderFlashCount % THUNDER_TWICE != 0)
{
ThunderFlash.SetActive(false);
m_thunderFlashCount++;
}
}
else
{
//雷が落ちる（稲妻が出現する）
MySoundManager.Instance.Play(SeCollection.Lightning);
Thunder.SetActive(true);
m_lightningStruck = true;
//落ちた時に雲は消え始める
m_cloudState = CloudState.Play;
}
}
else
{
//雷が落ちた後、稲妻の透明度を下げていく
ThunderRendererAlpha = ThunderRendererAlpha - (m_ChangeAlphaSpeed * Time.deltaTime);
ThunderColor.a = ThunderRendererAlpha;
ThunderRenderer.color = ThunderColor;
if (ThunderRendererAlpha <= 0)
{
ThunderRendererAlpha = ALPHA_MAX;
ThunderColor.a = ThunderRendererAlpha;
ThunderRenderer.color = ThunderColor;
Thunder.SetActive(false);
}
}
}
void Awake()
{
cloudRenderer = CloudPrefab.GetComponent <SpriteRenderer>();
cloudCollider = CloudPrefab.GetComponent <BoxCollider2D>();
cloudRenderer.enabled = false;
cloudCollider.enabled = false;
_timer = cloudTimer;
_cloudState = CloudState.Ready;
}
void Awake()
{
Indicator = Instantiate(Indicator, transform.position, transform.rotation);
indicatorRenderer = Indicator.GetComponent <SpriteRenderer>();
cloudCollider = Indicator.GetComponent <BoxCollider2D>();
indicatorRenderer.enabled = false;
cloudCollider.enabled = false;
_cloudTimer = LifeTime;
_cloudState = CloudState.Ready;
}
public void GetCandy()
{
candyGot++;
nowInThreshold = false;
CloudState = CloudState.NotAccepting;
cloudAnimator.SetTrigger("Chew");
cloudAnimator.SetTrigger("StopFlashing");
UpdateColor();
if (candyGot == targetCandy)
{
cloudAnimator.SetTrigger("Success");
}
}
private void ToggleCloudState()
{
_cloudState = _cloudState == CloudState.Normal ? CloudState.Storm : CloudState.Normal;
if (_cloudState == CloudState.Storm)
{
_cloudStyleControl.SetStormMaterial();
}
else
{
_cloudStyleControl.SetNormalMaterial();
}
}
public void FindImageOfCloudRecognition()
{
if (autoState)
{
return;
}
new Thread(() => {
TrackingState trackingState = TrackerManager.GetInstance().GetTrackingState();
TrackingResult trackingResult = trackingState.GetTrackingResult();
TrackedImage trackedImage = trackingState.GetImage();
int trackingCount = trackingResult.GetCount();
if (trackingCount == 0)
{
if (cloudState == CloudState.CLOUDSTATE_TRACKING || cloudState == CloudState.CLOUDSTATE_STOP)
{
cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
}
}
else
{
cloudState = CloudState.CLOUDSTATE_TRACKING;
}
if (cloudState != CloudState.CLOUDSTATE_FEATURE_COLLECT_READY)
{
return;
}
GetCloudRecognition(trackedImage, (bool cloudResult, string featureBase64) =>
{
if (cloudResult)
{
this.featureBase64 = featureBase64;
this.cloudState = CloudState.CLOUDSTATE_CONNECT;
}
else
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
}
if (this.restart)
{
this.loopState = true;
this.restart = false;
}
});
}).Start();
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// 雲の動き
/// </summary>
void CloudEvent()
{
switch (m_cloudState)
{
//雲が生成される
case CloudState.Generate:
if (m_cloudTime == 0)
{
ParticleCloud.Play();
m_cloudTime += Time.deltaTime;
}
else
{
ParticleCloud.Pause();
}
if (CloudObject.transform.position.y > CloudStopPositionObject.transform.position.y)
{
//雲の移動
CloudNextPosition.x = CloudObject.transform.position.x;
CloudNextPosition.y = CloudObject.transform.position.y - (10f * Time.deltaTime);
CloudNextPosition.z = CloudObject.transform.position.z;
CloudObject.transform.position = CloudNextPosition;
}
break;
//雲の動作
case CloudState.Play:
ParticleCloud.Play();
m_cloudState = CloudState.Progress;
break;
//雲が動いている
case CloudState.Progress:
m_cloudTime += Time.deltaTime;
if (m_cloudTime >= CLOUD_LIMIT_TIME)
{
m_cloudState = CloudState.Destroy;
m_cloudTime = 0;
CloudObject.transform.position = new Vector3(CloudObject.transform.position.x, DisplayUpOutsideObject.transform.position.y, CloudObject.transform.position.z);
}
break;
//雲が消えた
case CloudState.Destroy:
m_cloudState = CloudState.Non;
m_textMoving = true;
break;
}
}
//Tracks when cloud should decay regardless of ability selection
public void GroundCheck(PlayerController controller)
{
if (controller.grounded)
{
_groundReset = true;
}
switch (_cloudState)
{
#region Active
case CloudState.Active:
cloudCollider.enabled = true;
indicatorRenderer.color = new Color(1, 1, 1, Mathf.Lerp(0, 1, (_cloudTimer / 3.0f)));
if (_cloudTimer > 0)
{
_cloudTimer -= Time.deltaTime;
}
else
{
_cloudTimer = CloudCD;
_cloudState = CloudState.Cooldown;
}
break;
#endregion
#region Cooldown
case CloudState.Cooldown:
indicatorRenderer.enabled = false;
cloudCollider.enabled = false;
if (_cloudTimer > 0)
{
_cloudTimer -= Time.deltaTime;
}
else
{
_cloudTimer = LifeTime;
_cloudState = CloudState.Ready;
}
break;
#endregion
}
}
public void ShouldUnselectSelectedProvider()
{
var provider = new CloudState();
_state.Clouds.AddOrUpdate(provider);
_state.SelectedProviderId = provider.Id;
var model = BuildMainViewModel();
model.Clouds.Should().NotBeEmpty();
model.SelectedProvider.Should().NotBeNull();
model.SelectedProvider.Id.Should().Be(provider.Id);
model.Unselect.CanExecute().Should().BeTrue();
model.Unselect.Execute().Subscribe();
model.Clouds.Should().NotBeEmpty();
model.SelectedProvider.Should().BeNull();
}
public void ShouldUnselectProviderOnceDeleted()
{
var provider = new CloudState();
_state.Clouds.AddOrUpdate(new CloudState());
_state.Clouds.AddOrUpdate(provider);
_state.SelectedProviderId = provider.Id;
var model = BuildMainViewModel();
model.Clouds.Count.Should().Be(2);
model.SelectedProvider.Should().NotBeNull();
model.SelectedProvider.Id.Should().Be(provider.Id);
model.Remove.Execute().Subscribe();
model.SelectedProvider.Should().BeNull();
model.Clouds.Count.Should().Be(1);
}
public void ShouldSelectProviderFromStateWhenProvidersGetLoaded()
{
var provider = new CloudState();
_state.Clouds.AddOrUpdate(provider);
_state.SelectedProviderId = provider.Id;
var model = BuildMainViewModel();
model.Clouds.Should().NotBeEmpty();
model.SelectedProvider.Should().NotBeNull();
model.SelectedProvider.Id.Should().Be(provider.Id);
model.Refresh.Execute().Subscribe();
model.Clouds.Should().NotBeEmpty();
model.SelectedProvider.Should().NotBeNull();
model.SelectedProvider.Id.Should().Be(provider.Id);
}
internal void startTracker()
{
if (this.secretId != null && this.secretKey != null)
{
if (cloudState == CloudState.CLOUDSTATE_STOP)
{
cloudState = CloudState.CLOUDSTATE_START;
cloudThread = new Thread(startCloud)
{
Name = "CloudThread"
};
cloudThread.Start();
}
else
{
restart = true;
}
}
}
public void GroundCheck(PlayerController controller)
{
if (controller.grounded)
{
_groundReset = true;
}
switch (_cloudState)
{
case CloudState.Active:
cloudCollider.enabled = true;
cloudRenderer.color = new Color(1, 1, 1, Mathf.Lerp(0, 1, (_timer / 3.0f)));
if (_timer > 0)
{
_timer -= Time.deltaTime;
}
else
{
_timer = cloudCD;
_cloudState = CloudState.Cooldown;
}
break;
case CloudState.Cooldown:
cloudRenderer.enabled = false;
cloudCollider.enabled = false;
if (_timer > 0)
{
_timer -= Time.deltaTime;
}
else
{
_timer = cloudTimer;
_cloudState = CloudState.Ready;
}
break;
}
}
//----------------------------------------------------------------------------------------------------
/// <summary>
/// 進行イベント
/// </summary>
void PlayEvent()
{
if (!m_eventPlaying && m_textNum < MAX_TEXT_NUM)
{
if (m_cloudState != CloudState.Generate)
{
m_cloudState = CloudState.Generate;
}
m_waitingTime = m_waitingTime + Time.deltaTime;
if (m_waitingTime > m_textIntervalTime)
{
m_randomNum = UnityEngine.Random.Range(0, 3);
switch (m_randomNum)
{
case 0:
m_cloudDestroyCause = CloudDestroyCause.Jet;
break;
case 1:
m_cloudDestroyCause = CloudDestroyCause.Meteorite;
break;
case 2:
m_cloudDestroyCause = CloudDestroyCause.Thunder;
break;
}
m_waitingTime = 0;
}
}
if (m_ending)
{
m_endingImageRendererAlpha = m_endingImageRendererAlpha + (m_ChangeAlphaSpeed * Time.deltaTime);
EndingImageColor.a = m_endingImageRendererAlpha;
EndingImageRenderer.color = EndingImageColor;
if (m_endingImageRendererAlpha >= 1)
{
MySceneManager.Instance.ChangeScene(MyScene.Title);
}
}
}
public void PlayAnimation(CloudState cloudState)
{
if (cloudState == null)
{
cloudState = CloudState.OPENANDCLOSE;
}
mCloudState = cloudState;
if (cloudState == CloudState.OPEN)
{
Mask.Play("OpenCloudAnimation", 0, 0);
}
else if (cloudState == CloudState.OPENANDCLOSE)
{
Mask.Play("OpenCloudAnimation", 0, 0);
}
else if (cloudState == CloudState.CLOESE)
{
Mask.Play("CloseCloudAnimation", 0, 0);
}
}
void LateUpdate()
{
if (Mathf.Abs(gameObject.transform.position.x - targetBird.position.x) < 1.2f)
{
StartCoroutine(TurningToRain(0.4f));
anim.SetFloat(State, 1);
if (!rain.isPlaying)
{
rain.Play();
}
}
else
{
len = 0f;
cloudState = CloudState.IDLE;
anim.SetFloat(State, 0);
if (rain.isPlaying)
{
rain.Stop();
}
}
}
public void Activate(PlayerController player)
{
switch (_cloudState)
{
case CloudState.Ready:
//get mouse position
Vector3 mousePos2D = Camera.main.ScreenToWorldPoint(Input.mousePosition);
mousePos2D.z = 0;
//set cloud position to mouse
Indicator.transform.position = mousePos2D;
indicatorRenderer.enabled = true;
//make indicator opaque when cloud isn't out
indicatorRenderer.color = new Color(1, 1, 1, 0.5f);
if (InputController.Instance.Ability.Down)
{
_cloudState = CloudState.Active;
}
break;
}
}
public void Activate(PlayerController player)
{
switch (_cloudState)
{
case CloudState.Ready:
//get mouse position
Vector3 mousePos2D = Camera.main.ScreenToWorldPoint(Input.mousePosition);
mousePos2D.z = 0;
//set cloud position to mouse
CloudPrefab.transform.position = mousePos2D;
cloudRenderer.enabled = true;
cloudRenderer.color = new Color(1, 1, 1, 0.5f);
if (InputController.Instance.Ability.Down)
{
//change state to active
_cloudState = CloudState.Active;
}
break;
}
}
public CloudViewModel(
CloudState state,
CreateFolderViewModelFactory createFolderFactory,
RenameFileViewModelFactory renameFactory,
FileViewModelFactory fileFactory,
FolderViewModelFactory folderFactory,
IAuthViewModel auth,
IFileManager files,
ICloud cloud)
{
_cloud = cloud;
Folder = createFolderFactory(this);
Rename = renameFactory(this);
Auth = auth;
var canInteract = this
.WhenAnyValue(
x => x.Folder.IsVisible,
x => x.Rename.IsVisible,
(folder, rename) => !folder && !rename);
_canInteract = canInteract
.ToProperty(this, x => x.CanInteract);
var canRefresh = this
.WhenAnyValue(
x => x.Folder.IsVisible,
x => x.Rename.IsVisible,
x => x.Auth.IsAuthenticated,
(folder, rename, authenticated) => !folder && !rename && authenticated);
Refresh = ReactiveCommand.CreateFromTask(
() => cloud.GetFiles(CurrentPath),
canRefresh);
_files = Refresh
.Select(
items => items
.Select(file => fileFactory(file, this))
.OrderByDescending(file => file.IsFolder)
.ThenBy(file => file.Name)
.ToList())
.Where(items => Files == null || !items.SequenceEqual(Files))
.ToProperty(this, x => x.Files);
_isLoading = Refresh
.IsExecuting
.ToProperty(this, x => x.IsLoading);
_isReady = Refresh
.IsExecuting
.Skip(1)
.Select(executing => !executing)
.ToProperty(this, x => x.IsReady);
var canOpenCurrentPath = this
.WhenAnyValue(x => x.SelectedFile)
.Select(file => file != null && file.IsFolder)
.CombineLatest(Refresh.IsExecuting, canInteract, (folder, busy, ci) => folder && ci && !busy);
Open = ReactiveCommand.Create(
() => Path.Combine(CurrentPath, SelectedFile.Name),
canOpenCurrentPath);
var canCurrentPathGoBack = this
.WhenAnyValue(x => x.CurrentPath)
.Where(path => path != null)
.Select(path => path.Length > cloud.InitialPath.Length)
.CombineLatest(Refresh.IsExecuting, canInteract, (valid, busy, ci) => valid && ci && !busy);
Back = ReactiveCommand.Create(
() => Path.GetDirectoryName(CurrentPath),
canCurrentPathGoBack);
SetPath = ReactiveCommand.Create <string, string>(path => path);
_currentPath = Open
.Merge(Back)
.Merge(SetPath)
.Select(path => path ?? cloud.InitialPath)
.DistinctUntilChanged()
.Log(this, $"Current path changed in {cloud.Name}")
.ToProperty(this, x => x.CurrentPath, state.CurrentPath ?? cloud.InitialPath);
var getBreadCrumbs = ReactiveCommand.CreateFromTask(
() => cloud.GetBreadCrumbs(CurrentPath));
_breadCrumbs = getBreadCrumbs
.Where(items => items != null && items.Any())
.Select(items => items.Select(folder => folderFactory(folder, this)))
.ToProperty(this, x => x.BreadCrumbs);
_showBreadCrumbs = getBreadCrumbs
.ThrownExceptions
.Select(exception => false)
.Merge(getBreadCrumbs.Select(items => items != null && items.Any()))
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.ShowBreadCrumbs);
_hideBreadCrumbs = this
.WhenAnyValue(x => x.ShowBreadCrumbs)
.Select(show => !show)
.ToProperty(this, x => x.HideBreadCrumbs);
this.WhenAnyValue(x => x.CurrentPath, x => x.IsReady)
.Where(x => x.Item1 != null && x.Item2)
.Select(_ => Unit.Default)
.InvokeCommand(getBreadCrumbs);
this.WhenAnyValue(x => x.CurrentPath)
.Skip(1)
.Select(_ => Unit.Default)
.InvokeCommand(Refresh);
this.WhenAnyValue(x => x.CurrentPath)
.Subscribe(_ => SelectedFile = null);
_isCurrentPathEmpty = this
.WhenAnyValue(x => x.Files)
.Skip(1)
.Where(items => items != null)
.Select(items => !items.Any())
.ToProperty(this, x => x.IsCurrentPathEmpty);
_hasErrorMessage = Refresh
.ThrownExceptions
.Select(exception => true)
.ObserveOn(RxApp.MainThreadScheduler)
.Merge(Refresh.Select(x => false))
.ToProperty(this, x => x.HasErrorMessage);
var canUploadToCurrentPath = this
.WhenAnyValue(x => x.CurrentPath)
.Select(path => path != null)
.CombineLatest(Refresh.IsExecuting, canInteract, (up, loading, can) => up && can && !loading);
UploadToCurrentPath = ReactiveCommand.CreateFromObservable(
() => Observable
.FromAsync(files.OpenRead)
.Where(response => response.Name != null && response.Stream != null)
.Select(args => _cloud.UploadFile(CurrentPath, args.Stream, args.Name))
.SelectMany(task => task.ToObservable()),
canUploadToCurrentPath);
UploadToCurrentPath.InvokeCommand(Refresh);
var canDownloadSelectedFile = this
.WhenAnyValue(x => x.SelectedFile)
.Select(file => file != null && !file.IsFolder)
.CombineLatest(Refresh.IsExecuting, canInteract, (down, loading, can) => down && !loading && can);
DownloadSelectedFile = ReactiveCommand.CreateFromObservable(
() => Observable
.FromAsync(() => files.OpenWrite(SelectedFile.Name))
.Where(stream => stream != null)
.Select(stream => _cloud.DownloadFile(SelectedFile.Path, stream))
.SelectMany(task => task.ToObservable()),
canDownloadSelectedFile);
var canLogout = cloud
.IsAuthorized
.DistinctUntilChanged()
.Select(loggedIn => loggedIn && (
cloud.SupportsDirectAuth ||
cloud.SupportsOAuth ||
cloud.SupportsHostAuth))
.CombineLatest(canInteract, (logout, interact) => logout && interact)
.ObserveOn(RxApp.MainThreadScheduler);
Logout = ReactiveCommand.CreateFromTask(cloud.Logout, canLogout);
_canLogout = canLogout
.ToProperty(this, x => x.CanLogout);
var canDeleteSelection = this
.WhenAnyValue(x => x.SelectedFile)
.Select(file => file != null && !file.IsFolder)
.CombineLatest(Refresh.IsExecuting, canInteract, (del, loading, ci) => del && !loading && ci);
DeleteSelectedFile = ReactiveCommand.CreateFromTask(
() => cloud.Delete(SelectedFile.Path, SelectedFile.IsFolder),
canDeleteSelection);
DeleteSelectedFile.InvokeCommand(Refresh);
var canUnselectFile = this
.WhenAnyValue(x => x.SelectedFile)
.Select(selection => selection != null)
.CombineLatest(Refresh.IsExecuting, canInteract, (sel, loading, ci) => sel && !loading && ci);
UnselectFile = ReactiveCommand.Create(
() => { SelectedFile = null; },
canUnselectFile);
UploadToCurrentPath.ThrownExceptions
.Merge(DeleteSelectedFile.ThrownExceptions)
.Merge(DownloadSelectedFile.ThrownExceptions)
.Merge(Refresh.ThrownExceptions)
.Merge(getBreadCrumbs.ThrownExceptions)
.Log(this, $"Exception occured in provider {cloud.Name}")
.Subscribe();
this.WhenAnyValue(x => x.CurrentPath)
.Subscribe(path => state.CurrentPath = path);
this.WhenAnyValue(x => x.Auth.IsAuthenticated)
.Select(authenticated => authenticated ? _cloud.Parameters?.Token : null)
.Subscribe(token => state.Token = token);
this.WhenAnyValue(x => x.Auth.IsAuthenticated)
.Select(authenticated => authenticated ? _cloud.Parameters?.User : null)
.Subscribe(user => state.User = user);
this.WhenActivated(ActivateAutoRefresh);
}
public void EnterDroppingState()
{
CloudState = CloudState.Dropping;
}
void StartBack()
{
this.myState = CloudState.Back;
Destroy (this.gameObject, duration + 1.0f);
}
void Move()
{
Vector3 newpos = new Vector3 (0.0f, this.transform.position.y, this.transform.position.z);
newpos.x = Mathf.SmoothDamp (this.transform.position.x, this.destinationPoint.x, ref xVelocity, duration);
//newpos.x = Mathf.Lerp (this.transform.position.x, this.destinationPoint.x, 0.01f);
this.transform.position = newpos;
nowTime += Time.deltaTime;
if (xVelocity <= 0.5f && nowTime >= nextTime && onceFlag == true) {
myState = CloudState.Spark;
this.myMecanimAnimator.SetTrigger ("doSpark");
onceFlag = false;
}
}
private IEnumerator TurningToRain(float time)
{
yield return(new WaitForSeconds(time));
cloudState = CloudState.RAINNING;
}
internal void StopTracker()
{
autoState = true;
this.cloudState = CloudState.CLOUDSTATE_STOP;
}
internal void StartCloud()
{
loopState = true;
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
while (this.loopState)
{
Thread.Sleep(100);
TrackingState trackingState = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = trackingState.GetTrackingResult();
TrackedImage trackedImage = trackingState.GetImage();
int trackingCount = trackingResult.GetCount();
if (trackingCount == 0)
{
if (cloudState == CloudState.CLOUDSTATE_TRACKING)
{
cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
}
}
else
{
cloudState = CloudState.CLOUDSTATE_TRACKING;
}
if (trackingCount == 0 && (cloudState == CloudState.CLOUDSTATE_TRACKING || cloudState == CloudState.CLOUDSTATE_FEATURE_COLLECT_READY))
{
if (!TrackerManager.GetInstance().IsTrackerDataLoadCompleted() || cloudState == CloudState.CLOUDSTATE_STOP)
{
continue;
}
isGetFeatureState = true;
bool isCameraMove = CameraDevice.GetInstance().CheckCameraMove(trackedImage);
isGetFeatureState = false;
if (isCameraMove)
{
GetCloudRecognition(trackedImage, (bool cloudResult, string featureBase64) =>
{
if (cloudResult)
{
this.featureBase64 = featureBase64;
this.cloudState = CloudState.CLOUDSTATE_CONNECT;
}
else
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
}
if (this.restart)
{
this.loopState = true;
this.restart = false;
}
cloudSemaphore.Release();
});
cloudSemaphore.WaitOne();
}
}
if (this.cloudState == CloudState.CLOUDSTATE_STOP)
{
this.loopState = false;
}
}
}
private void Update()
{
if (cloudState == CloudState.CLOUDSTATE_CONNECT)
{
cloudState = CloudState.CLOUDSTATE_CONNECTING;
CloudRecognitionAPIController.Instance.Recognize(this.secretId, this.secretKey, featureBase64, (recognitionResult) =>
{
if (this.restart == true && recognitionResult == null)
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
return;
}
CloudRecognitionData cloudRecognitionData = null;
try
{
cloudRecognitionData = JsonReader.Deserialize <CloudRecognitionData>(recognitionResult);
}
catch (Exception ex)
{
Debug.Log("error");
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
return;
}
if (recognitionResult != null && cloudRecognitionData.ImgId != "" && cloudRecognitionData.ImgGSUrl != "")
{
Debug.Log(recognitionResult);
string fileName = Path.GetFileName(cloudRecognitionData.ImgGSUrl);
CloudRecognitionAPIController.Instance.DownloadCloudDataAndSave(cloudRecognitionData.ImgGSUrl, fileName, (localPath) =>
{
if (this.restart == true)
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
return;
}
if (localPath == null)
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
return;
}
TrackingState trackingState = TrackerManager.GetInstance().GetTrackingState();
TrackingResult trackingResult = trackingState.GetTrackingResult();
if (trackingResult.GetCount() > 0)
{
cloudState = CloudState.CLOUDSTATE_TRACKING;
}
else
{
string mapDirectory = Path.GetDirectoryName(localPath);
string mapFilePath = mapDirectory + "/" + Path.GetFileNameWithoutExtension(localPath) + ".2dmap";
string imageFilePath = localPath;
string customToBase64 = "";
if (cloudRecognitionData.Custom != null)
{
byte[] customToByteArray = Encoding.UTF8.GetBytes(cloudRecognitionData.Custom);
customToBase64 = Convert.ToBase64String(customToByteArray);
}
string command = "";
if (File.Exists(mapFilePath))
{
command = "{\"cloud\":\"add_image\",\"cloud_2dmap_path\":\"" + mapFilePath + "\",\"image_width\":" + cloudRecognitionData.RealWidth + ",\"cloud_name\":\"" + cloudRecognitionData.Name + "\",\"cloud_meta\":\"" + customToBase64 + "\"}";
}
else
{
command = "{\"cloud\":\"add_image\",\"cloud_image_path\":\"" + imageFilePath + "\",\"output_path\":\"" + mapFilePath + "\",\"image_width\":" + cloudRecognitionData.RealWidth + ",\"cloud_name\":\"" + cloudRecognitionData.Name + "\",\"cloud_meta\":\"" + customToBase64 + "\"}";
}
if (this.restart == true || command == "")
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
return;
}
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_IMAGE);
CloudRecognizerCache.GetInstance().ADD(fileName, command);
CloudRecognizerCache.GetInstance().LOAD();
cloudState = CloudState.CLOUDSTATE_TRACKING;
}
});
}
else
{
this.cloudState = CloudState.CLOUDSTATE_FEATURE_COLLECT_READY;
}
});
}
}