//---------------------------------------
// 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);
}
