//--------------------------------------- // Detection Logic //--------------------------------------- void UpdateDetectState() { if (MazeUTL.CheckTargetInRangeAndDetectRegion(CurrentTile, level.playerCharacter.CurrentTile, detectRange)) { detectState = DetectState.Alerted; } }
public void InstallWorkloadPacks(IEnumerable <PackInfo> packInfos, SdkFeatureBand sdkFeatureBand, ITransactionContext transactionContext, DirectoryPath?offlineCache = null) { ReportPendingReboot(); var msisToInstall = GetMsisToInstall(packInfos); foreach (var msiToInstall in msisToInstall) { transactionContext.Run(action: () => { try { // Retrieve the payload from the MSI package cache. MsiPayload msi = GetCachedMsiPayload(msiToInstall.NuGetPackageId, msiToInstall.NuGetPackageVersion, offlineCache); VerifyPackage(msi); DetectState state = DetectPackage(msi, out Version installedVersion); InstallAction plannedAction = PlanPackage(msi, state, InstallAction.Install, installedVersion, out _); ExecutePackage(msi, plannedAction); // Update the reference count against the MSI. UpdateDependent(InstallRequestType.AddDependent, msi.Manifest.ProviderKeyName, _dependent); } catch (Exception e) { LogException(e); throw; } }, rollback: () => { RollBackMsiInstall(msiToInstall); }); } }
void Start() { targetedPosition = hoverboard.transform.position; currentYValue = targetedPosition.y; currentState = hoverboard.GetComponent<DetectState>(); }
void Start() { targetedPosition = hoverboard.transform.position; currentYValue = targetedPosition.y; currentState = hoverboard.GetComponent <DetectState>(); }
public void InstallWorkloadPack(PackInfo packInfo, SdkFeatureBand sdkFeatureBand, DirectoryPath?offlineCache = null) { try { ReportPendingReboot(); // Determine the MSI payload package ID based on the host architecture, pack ID and pack version. string msiPackageId = GetMsiPackageId(packInfo); // Retrieve the payload from the MSI package cache. MsiPayload msi = GetCachedMsiPayload(msiPackageId, packInfo.Version, offlineCache); VerifyPackage(msi); DetectState state = DetectPackage(msi, out Version installedVersion); InstallAction plannedAction = PlanPackage(msi, state, InstallAction.Install, installedVersion, out _); ExecutePackage(msi, plannedAction); // Update the reference count against the MSI. UpdateDependent(InstallRequestType.AddDependent, msi.Manifest.ProviderKeyName, _dependent); } catch (Exception e) { LogException(e); RollBackWorkloadPackInstall(packInfo, sdkFeatureBand, offlineCache); } }
IEnumerator CoolDownDetectionLevel(float time) { float timer = time; while (timer > 0) { timer -= Time.deltaTime; yield return(null); } switch (detectState) { case DetectState.Alerted: detectState = DetectState.Warning; break; case DetectState.Warning: detectState = DetectState.Idle; break; default: case DetectState.Idle: break; } }
public IEnumerator UpdateVisibleCharacterRoutine() { while (true) { if (farSightCollider.IsInsideRange) { if (IsInFieldOfView(farSightAngle) && HasLineOfSight(farSightRange)) { detectState = DetectState.Sight; } if (detectorCollider.IsInsideRange && IsInFieldOfView(angleFov)) { if (HasLineOfSight(detectorRange)) { detectState = DetectState.Detected; } } } else { detectState = DetectState.Nothing; } yield return(null); } }
// Use this for initialization void Start () { boostParticles = transform.Find("Char02_Rig02_Hoverboard_Full_body_ctrl/Main_ctrl/Spin_Ctrl/Hoverboard_01/Boost").GetComponent<ParticleSystem>(); railParticles = transform.Find("Char02_Rig02_Hoverboard_Full_body_ctrl/Main_ctrl/Spin_Ctrl/Hoverboard_01/RailSparks").GetComponent<ParticleSystem>(); detectState = logicBoard.GetComponent<DetectState> (); movement = logicBoard.GetComponent<Movement> (); energy = logicBoard.GetComponent<EnergyPool> (); }
void Start() { currentState = gameObject.GetComponent <DetectState> (); boostScript = gameObject.GetComponent <Boost>(); rayDirection = -Vector3.up; direction = transform.forward; CustomJumpVec = Vector3.up; }
// Use this for initialization void Start() { boostParticles = transform.Find("Char02_Rig02_Hoverboard_Full_body_ctrl/Main_ctrl/Spin_Ctrl/Hoverboard_01/Boost").GetComponent<ParticleSystem>(); railParticles = transform.Find("Char02_Rig02_Hoverboard_Full_body_ctrl/Main_ctrl/Spin_Ctrl/Hoverboard_01/RailSparks").GetComponent<ParticleSystem>(); detectState = logicBoard.GetComponent<DetectState> (); movement = logicBoard.GetComponent<Movement> (); energy = logicBoard.GetComponent<EnergyPool> (); }
/// <summary> /// Determines the state of the specified product. /// </summary> /// <param name="productCode">The product code of the MSI to detect.</param> /// <param name="installedVersion">If detected, contains the version of the installed MSI.</param> /// <returns>The detect state of the specified MSI.</returns> private DetectState Detect(string productCode, out string installedVersion) { uint error = WindowsInstaller.GetProductInfo(productCode, InstallProperty.VERSIONSTRING, out installedVersion); DetectState state = error == Error.SUCCESS ? DetectState.Present : (error == Error.UNKNOWN_PRODUCT) || (error == Error.UNKNOWN_PROPERTY) ? DetectState.Absent : DetectState.Unknown; ExitOnError(state == DetectState.Unknown, error, $"Failed to detect MSI package with ProductCode={productCode}."); Log?.LogMessage($"Detected package, ProductCode: {productCode}, version: {(string.IsNullOrWhiteSpace(installedVersion) ? "n/a" : $"{installedVersion}")}, state: {state}.");
void OnTriggerEnter(Collider col) { Wallactive = true; detectState = col.GetComponent <DetectState> (); if (Vector3.Angle(transform.right, col.transform.right) < 90) { direction = new Vector3(transform.forward.x, 0, transform.forward.z); } else { direction = new Vector3(-transform.forward.x, 1, -transform.forward.z); } }
void OnTriggerEnter(Collider col) { Wallactive = true; detectState = col.GetComponent<DetectState> (); if(Vector3.Angle(transform.right, col.transform.right) <90) { direction = new Vector3(transform.forward.x, 0, transform.forward.z); } else { direction = new Vector3(-transform.forward.x, 1, -transform.forward.z); } }
public void UpdateDetectStateIcon(DetectState state) { if (state == DetectState.Warning) { detectStateIcon.UpdateSprite("Icon-Warning"); detectStateIcon.UpdateSpriteAlpha(1); } else if (state == DetectState.Alerted) { detectStateIcon.UpdateSprite("Icon-Alerted"); detectStateIcon.UpdateSpriteAlpha(1); } else { detectStateIcon.UpdateSpriteAlpha(0); } }
// Use this for initialization void Start() { timeToChange = 0; anglesMovingTo.Set(0, 0, 0, 0); if (canRecordThisHoverboard) { currentState = hoverboard.GetComponent <DetectState>(); movement = hoverboard.GetComponent <Movement>(); } if (!isRecording) { fetchFromTextFile = true; } filepath = Application.persistentDataPath + "/Ghost.txt"; timeToLerp = 1 / (m_howManyTimesPerSecond); reduceLerpTime = timeToLerp / (m_howManyTimesPerSecond); }
public void RollBackWorkloadPackInstall(PackInfo packInfo, SdkFeatureBand sdkFeatureBand, DirectoryPath?offlineCache = null) { try { ReportPendingReboot(); Log?.LogMessage($"Rolling back workload pack installation for {packInfo.ResolvedPackageId}."); // Determine the MSI payload package ID based on the host architecture, pack ID and pack version. string msiPackageId = GetMsiPackageId(packInfo); // Retrieve the payload from the MSI package cache. MsiPayload msi = GetCachedMsiPayload(msiPackageId, packInfo.Version, offlineCache); VerifyPackage(msi); // Check the provider key first in case we were installed and we only need to remove // a dependent. DependencyProvider depProvider = new DependencyProvider(msi.Manifest.ProviderKeyName); // Try and remove the dependent against this SDK. If any remain we'll simply exit. UpdateDependent(InstallRequestType.RemoveDependent, msi.Manifest.ProviderKeyName, _dependent); if (depProvider.Dependents.Any()) { Log?.LogMessage($"Cannot remove pack, other dependents remain: {string.Join(", ", depProvider.Dependents)}."); return; } // Make sure the MSI is actually installed. DetectState state = DetectPackage(msi, out Version installedVersion); InstallAction plannedAction = PlanPackage(msi, state, InstallAction.Uninstall, installedVersion, out _); // The previous steps would have logged the final action. If the verdict is not to uninstall we can exit. if (plannedAction == InstallAction.Uninstall) { ExecutePackage(msi, plannedAction); } Log?.LogMessage("Rollback completed."); } catch (Exception e) { LogException(e); throw; } }
void UpdateMoveSpeed(DetectState state) { switch (state) { case DetectState.Idle: MoveSpeed = moveSpeedIdle; break; case DetectState.Warning: MoveSpeed = moveSpeedWarning; break; default: case DetectState.Alerted: MoveSpeed = moveSpeedAlerted; break; } }
public void InstallWorkloadPack(PackInfo packInfo, SdkFeatureBand sdkFeatureBand, DirectoryPath?offlineCache = null) { try { // Determine the MSI payload package ID based on the host architecture, pack ID and pack version. string msiPackageId = GetMsiPackageId(packInfo); // Retrieve the payload from the MSI package cache. MsiPayload msiPayload = GetCachedMsiPayload(msiPackageId, packInfo.Version); VerifyPackage(msiPayload); DetectState state = Detect(msiPayload.Manifest.ProductCode, out string _); PlanAndExecute(msiPayload, packInfo, state, InstallAction.Install); // Update the reference count against the MSI. UpdateDependent(InstallRequestType.AddDependent, msiPayload.Manifest.ProviderKeyName, _dependent); } catch (Exception e) { LogException(e); throw; } }
/// <summary> /// Determines the state of the specified product. /// </summary> /// <param name="productCode">The product code of the MSI to detect.</param> /// <param name="installedVersion">If detected, contains the version of the installed MSI.</param> /// <returns>The detect state of the specified MSI.</returns> private DetectState DetectPackage(string productCode, out Version installedVersion) { installedVersion = default; uint error = WindowsInstaller.GetProductInfo(productCode, InstallProperty.VERSIONSTRING, out string versionValue); DetectState state = error == Error.SUCCESS ? DetectState.Present : (error == Error.UNKNOWN_PRODUCT) || (error == Error.UNKNOWN_PROPERTY) ? DetectState.Absent : DetectState.Unknown; ExitOnError(state == DetectState.Unknown, error, $"DetectPackage: Failed to detect MSI package, ProductCode: {productCode}."); if (state == DetectState.Present) { if (!Version.TryParse(versionValue, out installedVersion)) { Log?.LogMessage($"DetectPackage: Failed to parse version: {versionValue}."); } } Log?.LogMessage($"DetectPackage: ProductCode: {productCode}, version: {installedVersion?.ToString() ?? "n/a"}, state: {state}."); return(state); }
void OnTriggerEnter(Collider col) { player = col.gameObject; detectState = player.gameObject.GetComponent<DetectState> (); if(player.transform.localScale.x != 2) { GlobalFuncVari.setRailBounds(col.transform.localScale); player.transform.localScale = new Vector3 (2, player.transform.localScale.y, 2) ; } if(GlobalFuncVari.getNum() == 0) { if(Vector3.Angle(transform.forward, player.transform.right) <= 90) { GlobalFuncVari.railFalse(); detectState.updateKeyState ("Rail").setVector = -transform.right; } else { GlobalFuncVari.railTrue(); detectState.updateKeyState ("Rail").setVector = transform.right; } } else if(GlobalFuncVari.getallowRail()) { detectState.m_getRayCastState = false; detectState.changeKeyState("Rail"); detectState.m_getRailPermission = false; if(GlobalFuncVari.getRailbool()) { push = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y+90, player.transform.eulerAngles.z); player.transform.position = transform.position + (player.transform.position-transform.position).magnitude*-transform.right; player.transform.eulerAngles = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y+90, player.transform.eulerAngles.z); detectState.updateKeyState ("Rail").setVector = transform.right; } else { push = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y-90, player.transform.eulerAngles.z); player.transform.position = transform.position + (player.transform.position-transform.position).magnitude*transform.right; player.transform.eulerAngles = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y-90, player.transform.eulerAngles.z); detectState.updateKeyState ("Rail").setVector = -transform.right; } } Grindactive = true; GlobalFuncVari.incNum(); if(detectState.m_getRailPermission) { detectState.m_getRayCastState = false; detectState.changeKeyState("Rail"); detectState.m_getRailPermission = false; GlobalFuncVari.allowRailTrue(); if(GlobalFuncVari.getRailbool()) { player.transform.position = transform.position + (player.transform.position-transform.position).magnitude*-transform.right; player.transform.eulerAngles = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y+90, player.transform.eulerAngles.z); push = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y+90, player.transform.eulerAngles.z); } else { player.transform.position = transform.position + (player.transform.position-transform.position).magnitude*transform.right; player.transform.eulerAngles = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y-90, player.transform.eulerAngles.z); push = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y-90, player.transform.eulerAngles.z); } } }
/// <summary> /// Plans the specified MSI payload based on its state and the requested install action. /// </summary> /// <param name="msi">The MSI package to plan.</param> /// <param name="state">The detected state of the package.</param> /// <param name="requestedAction">The requested action to perform.</param> /// <returns>The action that will be performed.</returns> private InstallAction PlanPackage(MsiPayload msi, DetectState state, InstallAction requestedAction, Version installedVersion, out IEnumerable <string> relatedProductCodes) { InstallAction plannedAction = InstallAction.None; HashSet <string> relatedProducts = new(); Log?.LogMessage($"PlanPackage: Begin, name: {msi.Name}, version: {msi.ProductVersion}, state: {state}, installed version: {installedVersion?.ToString() ?? "n/a"}, requested: {requestedAction}."); // Manifest packages should support major upgrades (both the ProductCode and ProductVersion should be different) while // workload packs should always be SxS (ProductCode and Upgrade should be different for each version). // // We cannot discount someone generating a minor update (ProductCode remains unchanged, but ProductVersion changes), // so we'll detect downgrades and minor updates. For more details, see https://docs.microsoft.com/en-us/windows/win32/msi/minor-upgrades. if (state == DetectState.Present) { if (msi.ProductVersion < installedVersion) { Log?.LogMessage($"PlanPackage: Downgrade detected, installed version: {installedVersion}, requested version: {msi.ProductVersion}."); plannedAction = InstallAction.Downgrade; state = DetectState.Superseded; } else if (msi.ProductVersion > installedVersion) { Log?.LogMessage($"PlanPackage: Minor update detected, installed version: {installedVersion}, requested version: {msi.ProductVersion}."); plannedAction = InstallAction.MinorUpdate; state = DetectState.Obsolete; } else { // If the package is installed, then we can uninstall and repair it. plannedAction = (requestedAction != InstallAction.Repair) && (requestedAction != InstallAction.Uninstall) ? InstallAction.None : requestedAction; } } else if (state == DetectState.Absent) { // If we're absent, convert repair to install or keep install. plannedAction = (requestedAction == InstallAction.Repair) ? InstallAction.Install : (requestedAction == InstallAction.Install) ? InstallAction.Install : InstallAction.None; } // At this point we know the MSI is absent so there are only three outcomes when executing the package: // 1. We'll just do a clean install if we don't find related products so we're either brand new or SxS. // 2. We'll perform a major upgrade. // 3. We'll trigger a downgrade and likely an error since most MSIs detect and block downgrades. // // We'll process the related product information to make a determination. This is similar to what the FindRelatedProducts // action does when an MSI is executed. foreach (RelatedProduct relatedProduct in msi.RelatedProducts) { foreach (string relatedProductCode in WindowsInstaller.FindRelatedProducts(relatedProduct.UpgradeCode)) { // Ignore potentially detecting ourselves. if (string.Equals(relatedProductCode, msi.ProductCode, StringComparison.OrdinalIgnoreCase)) { continue; } // Check whether the related product is installed and retrieve its version to determine // how we're related. uint error = WindowsInstaller.GetProductInfo(relatedProductCode, InstallProperty.VERSIONSTRING, out string relatedVersionValue); // Continue searching if the related product is not installed. if (error == Error.UNKNOWN_PRODUCT || error == Error.UNKNOWN_PROPERTY) { continue; } ExitOnError(error, $"PlanPackage: Failed to retrieve version for related product: ProductCode: {relatedProductCode}."); // Parse the version, but don't try to catch any errors. If the version is invalid we want to fail // because we can't compare invalid versions to see whether it's excluded by the VersionMin and VersionMax // columns from the Upgrade table. Version relatedVersion = Version.Parse(relatedVersionValue); if (relatedProduct.ExcludesMinVersion(relatedVersion) || relatedProduct.ExcludesMaxVersion(relatedVersion)) { continue; } // Check if the related product contains a matching language code (LCID). If we don't have any languages, // all languages are detectable as related and we can ignore the msidbUpgradeAttributesLanguagesExclusive flag. if (relatedProduct.Languages.Any()) { string relatedLanguage = "0"; error = WindowsInstaller.GetProductInfo(relatedProductCode, InstallProperty.LANGUAGE, out relatedLanguage); if (int.TryParse(relatedLanguage, out int lcid)) { if (relatedProduct.ExcludesLanguage(lcid)) { continue; } } else { Log?.LogMessage($"PlanPackage: Failed to read Language property for related product, ProductCode: {relatedProductCode}. The related product will be skipped."); continue; } } relatedProducts.Add(relatedProductCode); plannedAction = InstallAction.MajorUpgrade; if (relatedProduct.Attributes.HasFlag(UpgradeAttributes.OnlyDetect) && (state == DetectState.Absent)) { // If we're not installed, but detect-only related, it's very likely that // that we'd trigger a downgrade launch condition. We can't know for sure, but // generally that's the most common use for detect-only entries. plannedAction = InstallAction.Downgrade; } Log?.LogMessage($"PlanPackage: Detected related product, ProductCode: {relatedProductCode}, version: {relatedVersion}, attributes: {relatedProduct.Attributes}, planned action: {plannedAction}."); } } Log?.LogMessage($"PlanPackage: Completed, name: {msi.Name}, version: {msi.ProductVersion}, state: {state}, installed version: {installedVersion?.ToString() ?? "n/a"}, requested: {requestedAction}, planned: {plannedAction}."); relatedProductCodes = relatedProducts.Select(p => p); return(plannedAction); }
public void InstallWorkloadManifest(ManifestId manifestId, ManifestVersion manifestVersion, SdkFeatureBand sdkFeatureBand, DirectoryPath?offlineCache = null, bool isRollback = false) { try { ReportPendingReboot(); // Rolling back a manifest update after a successful install is essentially a downgrade, which is blocked so we have to // treat it as a special case and is different from the install failing and rolling that back, though depending where the install // failed, it may have removed the old product already. Log?.LogMessage($"Installing manifest: Id: {manifestId}, version: {manifestVersion}, feature band: {sdkFeatureBand}, rollback: {isRollback}."); // Resolve the package ID for the manifest payload package string msiPackageId = WorkloadManifestUpdater.GetManifestPackageId(sdkFeatureBand, manifestId, InstallType.Msi).ToString(); string msiPackageVersion = $"{manifestVersion}"; Log?.LogMessage($"Resolving {manifestId} ({manifestVersion}) to {msiPackageId} ({msiPackageVersion})."); // Retrieve the payload from the MSI package cache. MsiPayload msi = GetCachedMsiPayload(msiPackageId, msiPackageVersion, offlineCache); VerifyPackage(msi); DetectState state = DetectPackage(msi.ProductCode, out Version installedVersion); InstallAction plannedAction = PlanPackage(msi, state, InstallAction.Install, installedVersion, out IEnumerable <string> relatedProducts); // If we've detected a downgrade, it's possible we might be doing a rollback after the manifests were updated, // but another error occurred. In this case we need to try and uninstall the upgrade and then install the lower // version of the MSI. The downgrade can also be a deliberate rollback. if (plannedAction == InstallAction.Downgrade && isRollback && state == DetectState.Absent) { Log?.LogMessage($"Rolling back manifest update."); // The provider keys for manifest packages are stable across feature bands so we retain dependents during upgrades. DependencyProvider depProvider = new DependencyProvider(msi.Manifest.ProviderKeyName); // Try and remove the SDK dependency, but ignore any remaining dependencies since // we want to force the removal of the old version. The remaining dependencies and the provider // key won't be removed. UpdateDependent(InstallRequestType.RemoveDependent, msi.Manifest.ProviderKeyName, _dependent); // Since we don't have records for manifests, we need to try and retrieve the ProductCode of // the newer MSI that's installed that we want to remove using its dependency provider. string productCode = depProvider.ProductCode; if (string.IsNullOrWhiteSpace(productCode)) { // We don't know the MSI package that wrote this provider key, so if the ProductCode is missing // we can't do anything else. Log?.LogMessage($"Failed to retrieve the ProductCode for provider: {depProvider.ProviderKeyName}."); return; } Log?.LogMessage($"Found ProductCode {productCode} registered against provider, {depProvider.ProviderKeyName}."); // This is a best effort. If for some reason the manifest installers were fixed, for example, manually // adding additional upgrade paths to work around previous faulty authoring, we may have multiple related // products. The best we can do is to check for at least one match and remove it and then try the rollback. if (!relatedProducts.Contains(productCode, StringComparer.OrdinalIgnoreCase)) { Log?.LogMessage($"Cannot rollback manifest. ProductCode does not match any detected related products."); return; } string logFile = GetMsiLogName(productCode, InstallAction.Uninstall); uint error = UninstallMsi(productCode, logFile, ignoreDependencies: true); ExitOnError(error, "Failed to uninstall manifest package."); // Detect the package again and fall through to the original execution. If that fails, then there's nothing // we could have done. Log?.LogMessage("Replanning manifest package."); state = DetectPackage(msi, out Version _); plannedAction = PlanPackage(msi, state, InstallAction.Install, installedVersion, out IEnumerable <string> _); } ExecutePackage(msi, plannedAction); // Update the reference count against the MSI. UpdateDependent(InstallRequestType.AddDependent, msi.Manifest.ProviderKeyName, _dependent); } catch (Exception e) { LogException(e); throw; } }
void Start() { currentState = gameObject.GetComponent<DetectState> (); boostScript = gameObject.GetComponent<Boost>(); rayDirection = -Vector3.up; direction = transform.forward; CustomJumpVec = Vector3.up; }
void OnTriggerEnter(Collider col) { player = col.gameObject; detectState = player.gameObject.GetComponent <DetectState> (); if (player.transform.localScale.x != 2) { GlobalFuncVari.setRailBounds(col.transform.localScale); player.transform.localScale = new Vector3(2, player.transform.localScale.y, 2); } if (GlobalFuncVari.getNum() == 0) { if (Vector3.Angle(transform.forward, player.transform.right) <= 90) { GlobalFuncVari.railFalse(); detectState.updateKeyState("Rail").setVector = -transform.right; } else { GlobalFuncVari.railTrue(); detectState.updateKeyState("Rail").setVector = transform.right; } } else if (GlobalFuncVari.getallowRail()) { detectState.m_getRayCastState = false; detectState.changeKeyState("Rail"); detectState.m_getRailPermission = false; if (GlobalFuncVari.getRailbool()) { push = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y + 90, player.transform.eulerAngles.z); player.transform.position = transform.position + (player.transform.position - transform.position).magnitude * -transform.right; player.transform.eulerAngles = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y + 90, player.transform.eulerAngles.z); detectState.updateKeyState("Rail").setVector = transform.right; } else { push = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y - 90, player.transform.eulerAngles.z); player.transform.position = transform.position + (player.transform.position - transform.position).magnitude * transform.right; player.transform.eulerAngles = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y - 90, player.transform.eulerAngles.z); detectState.updateKeyState("Rail").setVector = -transform.right; } } Grindactive = true; GlobalFuncVari.incNum(); if (detectState.m_getRailPermission) { detectState.m_getRayCastState = false; detectState.changeKeyState("Rail"); detectState.m_getRailPermission = false; GlobalFuncVari.allowRailTrue(); if (GlobalFuncVari.getRailbool()) { player.transform.position = transform.position + (player.transform.position - transform.position).magnitude * -transform.right; player.transform.eulerAngles = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y + 90, player.transform.eulerAngles.z); push = new Vector3(-transform.eulerAngles.z, transform.eulerAngles.y + 90, player.transform.eulerAngles.z); } else { player.transform.position = transform.position + (player.transform.position - transform.position).magnitude * transform.right; player.transform.eulerAngles = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y - 90, player.transform.eulerAngles.z); push = new Vector3(transform.eulerAngles.z, transform.eulerAngles.y - 90, player.transform.eulerAngles.z); } } }
/// <summary> /// Cleans up and removes stale workload packs. /// </summary> public void GarbageCollectInstalledWorkloadPacks(DirectoryPath?offlineCache = null) { try { ReportPendingReboot(); Log?.LogMessage("Starting garbage collection."); IEnumerable <SdkFeatureBand> installedFeatureBands = GetInstalledFeatureBands(); IEnumerable <WorkloadId> installedWorkloads = RecordRepository.GetInstalledWorkloads(_sdkFeatureBand); Dictionary <(WorkloadPackId id, string version), PackInfo> expectedWorkloadPacks = installedWorkloads .SelectMany(workload => _workloadResolver.GetPacksInWorkload(workload)) .Distinct() .Select(pack => _workloadResolver.TryGetPackInfo(pack)) .Where(pack => pack != null) .ToDictionary(p => (new WorkloadPackId(p.ResolvedPackageId), p.Version)); foreach (PackInfo expectedPack in expectedWorkloadPacks.Values) { Log?.LogMessage($"Expected workload pack, ID: {expectedPack.ResolvedPackageId}, version: {expectedPack.Version}."); } foreach (SdkFeatureBand installedFeatureBand in installedFeatureBands) { Log?.LogMessage($"Installed feature band: {installedFeatureBand}"); } IEnumerable <WorkloadPackRecord> installedWorkloadPacks = GetWorkloadPackRecords(); List <WorkloadPackRecord> packsToRemove = new List <WorkloadPackRecord>(); // We first need to clean up the dependents and then do a pass at removing them. Querying the installed packs // is effectively a table scan of the registry to make sure we have accurate information and there's a // potential perf hit for both memory and speed when enumerating large sets of registry entries. foreach (WorkloadPackRecord packRecord in installedWorkloadPacks) { DependencyProvider depProvider = new DependencyProvider(packRecord.ProviderKeyName); // Find all the dependents that look like they belong to SDKs. We only care // about dependents that match the SDK host we're running under. For example, an x86 SDK should not be // modifying the x64 MSI dependents. IEnumerable <string> sdkDependents = depProvider.Dependents .Where(d => d.StartsWith($"{DependentPrefix}")) .Where(d => d.EndsWith($",{HostArchitecture}")); foreach (string dependent in sdkDependents) { Log?.LogMessage($"Evaluating dependent for workload pack, dependent: {dependent}, MSI ID: {packRecord.MsiId}, MSI version: {packRecord.MsiNuGetVersion}"); // Dependents created by the SDK should have 3 parts, for example, "Microsoft.NET.Sdk,6.0.100,x86". string[] dependentParts = dependent.Split(','); if (dependentParts.Length != 3) { Log?.LogMessage($"Skipping dependent: {dependent}"); continue; } try { SdkFeatureBand dependentFeatureBand = new SdkFeatureBand(dependentParts[1]); if (!installedFeatureBands.Contains(dependentFeatureBand)) { Log?.LogMessage($"Removing dependent '{dependent}' from provider key '{depProvider.ProviderKeyName}' because its SDK feature band does not match any installed feature bands."); UpdateDependent(InstallRequestType.RemoveDependent, depProvider.ProviderKeyName, dependent); } if (dependentFeatureBand.Equals(_sdkFeatureBand)) { // If the current SDK feature band is listed as a dependent, we can validate // the workload packs against the expected pack IDs and versions to potentially remove it. if (packRecord.InstalledPacks.All(p => !expectedWorkloadPacks.ContainsKey((p.id, p.version.ToString())))) { // None of the packs installed by this MSI are necessary any longer for this feature band, so we can remove the reference count Log?.LogMessage($"Removing dependent '{dependent}' because the pack record(s) do not match any expected packs."); UpdateDependent(InstallRequestType.RemoveDependent, depProvider.ProviderKeyName, dependent); } } } catch (Exception e) { Log?.LogMessage($"{e.Message}"); Log?.LogMessage($"{e.StackTrace}"); continue; } } // Recheck the registry to see if there are any remaining dependents. If not, we can // remove the workload pack. We'll add it to the list and remove the packs at the end. IEnumerable <string> remainingDependents = depProvider.Dependents; if (remainingDependents.Any()) { Log?.LogMessage($"{packRecord.MsiId} ({packRecord.MsiNuGetVersion}) will not be removed because other dependents remain: {string.Join(", ", remainingDependents)}."); } else { packsToRemove.Add(packRecord); } } foreach (WorkloadPackRecord record in packsToRemove) { // We need to make sure the product is actually installed and that we're not dealing with an orphaned record, e.g. // if a previous removal was interrupted. We can't safely clean up orphaned records because it's too expensive // to query all installed components and determine the product codes associated with the component that // created the record. DetectState state = DetectPackage(record.ProductCode, out Version _); if (state == DetectState.Present) { // Manually construct the MSI payload package details string id = $"{record.MsiId}.Msi.{HostArchitecture}"; MsiPayload msi = GetCachedMsiPayload(id, record.MsiNuGetVersion.ToString(), offlineCache); // Make sure the package we have in the cache matches with the record. If it doesn't, we'll do the uninstall // the hard way if (!string.Equals(record.ProductCode, msi.ProductCode, StringComparison.OrdinalIgnoreCase)) { Log?.LogMessage($"ProductCode mismatch! Cached package: {msi.ProductCode}, pack record: {record.ProductCode}."); string logFile = GetMsiLogName(record, InstallAction.Uninstall); uint error = ExecuteWithProgress(String.Format(LocalizableStrings.MsiProgressUninstall, id), () => UninstallMsi(record.ProductCode, logFile)); ExitOnError(error, $"Failed to uninstall {msi.MsiPath}."); } else { // No need to plan. We know that there are no other dependents, the MSI is installed and we // want to remove it. VerifyPackage(msi); ExecutePackage(msi, InstallAction.Uninstall); } } } } catch (Exception e) { LogException(e); throw; } }
/// <summary> /// Cleans up and removes stale workload packs. /// </summary> public void GarbageCollectInstalledWorkloadPacks() { try { Log?.LogMessage("Starting garbage collection."); IEnumerable <SdkFeatureBand> installedFeatureBands = GetInstalledFeatureBands(); IEnumerable <WorkloadId> installedWorkloads = RecordRepository.GetInstalledWorkloads(_sdkFeatureBand); IEnumerable <PackInfo> expectedWorkloadPacks = installedWorkloads .SelectMany(workload => _workloadResolver.GetPacksInWorkload(workload)) .Select(pack => _workloadResolver.TryGetPackInfo(pack)) .Where(pack => pack != null); IEnumerable <WorkloadPackId> expectedPackIds = expectedWorkloadPacks.Select(p => p.Id); foreach (PackInfo expectedPack in expectedWorkloadPacks) { Log?.LogMessage($"Expected workload pack, ID: {expectedPack.ResolvedPackageId}, version: {expectedPack.Version}."); } foreach (SdkFeatureBand installedFeatureBand in installedFeatureBands) { Log?.LogMessage($"Installed feature band: {installedFeatureBand}"); } IEnumerable <WorkloadPackRecord> installedWorkloadPacks = WorkloadPackRecords.Values.SelectMany(r => r); List <WorkloadPackRecord> packsToRemove = new List <WorkloadPackRecord>(); // We first need to clean up the dependents and then do a pass at removing them. Querying the installed packs // is effectively a table scan of the registry to make sure we have accurate information and there's a // potential perf hit for both memory and speed when enumerating large sets of registry entries. foreach (WorkloadPackRecord packRecord in installedWorkloadPacks) { DependencyProvider depProvider = new DependencyProvider(packRecord.ProviderKeyName); // Find all the dependents that look like they belong to SDKs. We only care // about dependents that match the SDK host we're running under. For example, an x86 SDK should not be // modifying the x64 MSI dependents. IEnumerable <string> sdkDependents = depProvider.Dependents .Where(d => d.StartsWith($"{DependentPrefix}")) .Where(d => d.EndsWith($",{HostArchitecture}")); foreach (string dependent in sdkDependents) { Log?.LogMessage($"Evaluating dependent for workload pack, dependent: {dependent}, pack ID: {packRecord.PackId}, pack version: {packRecord.PackVersion}"); // Dependents created by the SDK should have 3 parts, for example, "Microsoft.NET.Sdk,6.0.100,x86". string[] dependentParts = dependent.Split(','); if (dependentParts.Length != 3) { Log?.LogMessage($"Skipping dependent: {dependent}"); continue; } try { SdkFeatureBand dependentFeatureBand = new SdkFeatureBand(dependentParts[1]); if (!installedFeatureBands.Contains(dependentFeatureBand)) { Log?.LogMessage($"Removing dependent '{dependent}' from provider key '{depProvider.ProviderKeyName}' because its SDK feature band does not match any installed feature bands."); UpdateDependent(InstallRequestType.RemoveDependent, depProvider.ProviderKeyName, dependent); } if (dependentFeatureBand.Equals(_sdkFeatureBand)) { // If the current SDK feature band is listed as a dependent, we can validate // the workload pack against the expected pack IDs and versions to potentially remove it. if (!expectedWorkloadPacks.Where(p => packRecord.PackId.Equals(p.ResolvedPackageId)) .Where(p => p.Version.Equals(packRecord.PackVersion.ToString())).Any()) { Log?.LogMessage($"Removing dependent '{dependent}' because the pack record does not match any expected packs."); UpdateDependent(InstallRequestType.RemoveDependent, depProvider.ProviderKeyName, dependent); } } } catch (Exception e) { Log?.LogMessage($"{e.Message}"); Log?.LogMessage($"{e.StackTrace}"); continue; } } // Recheck the registry to see if there are any remaining dependents. If not, we can // remove the workload pack. We'll add it to the list and remove the packs at the end. IEnumerable <string> remainingDependents = depProvider.Dependents; if (remainingDependents.Any()) { Log?.LogMessage($"{packRecord.PackId} ({packRecord.PackVersion}) will not be removed because other dependents remain: {string.Join(", ", remainingDependents)}."); } else { packsToRemove.Add(packRecord); } } foreach (WorkloadPackRecord record in packsToRemove) { // We need to make sure the product is actually installed and that we're not dealing with an orphaned record, e.g. // if a previous removal was interrupted. We can't safely clean up orphaned records because it's too expensive // to query all installed components and determine the product codes associated with the component that // created the record. DetectState state = Detect(record.ProductCode, out string _); if (state == DetectState.Present) { // We don't have package information and can't construct it accurately. string id = $"{record.PackId}.Msi.{HostArchitecture}"; MsiPayload msiPayload = GetCachedMsiPayload(id, record.PackVersion.ToString()); VerifyPackage(msiPayload); InstallAction plannedAction = GetPlannedAction(state, InstallAction.Uninstall); string logFile = GetMsiLogName(record, plannedAction); uint error = ExecuteWithProgress($"Removing {id} ", () => UninstallMsi(record.ProductCode, logFile)); ExitOnError(error, $"Failed to uninstall {msiPayload.MsiPath}."); } } } catch (Exception e) { LogException(e); throw; } }
// Use this for initialization void Start() { timeToChange = 0; anglesMovingTo.Set (0, 0, 0, 0); if(canRecordThisHoverboard) { currentState = hoverboard.GetComponent<DetectState>(); movement = hoverboard.GetComponent<Movement>(); } if (!isRecording) fetchFromTextFile = true; filepath = Application.persistentDataPath + "/Ghost.txt"; timeToLerp = 1/(m_howManyTimesPerSecond); reduceLerpTime = timeToLerp / (m_howManyTimesPerSecond); }