public CollisionState2D CheckProximity(float distance, Direction2D mask)
{
var proximityCollision = new CollisionState2D();
// Check below
if (FlagsHelper.IsSet(mask, Direction2D.DOWN))
{
proximityCollision.Below = Check(Constants.Directions.DOWN, distance);
}
// Check above
if (FlagsHelper.IsSet(mask, Direction2D.UP))
{
proximityCollision.Above = Check(Constants.Directions.UP, distance);
}
// Check right.
if (FlagsHelper.IsSet(mask, Direction2D.RIGHT))
{
proximityCollision.Right = Check(Constants.Directions.RIGHT, distance);
}
// Check left
if (FlagsHelper.IsSet(mask, Direction2D.LEFT))
{
proximityCollision.Left = Check(Constants.Directions.LEFT, distance);
}
return(proximityCollision);
}
void OnSceneClean(GameMessage msg)
{
FlagsHelper.Unset(ref currentState, GameState.started);
FlagsHelper.Unset(ref currentState, GameState.ended);
FlagsHelper.Unset(ref currentState, GameState.arenaAnimating);
FlagsHelper.Unset(ref currentState, GameState.firstOut);
}
public CollisionState2D CheckProximity(float distance, Direction2D mask)
{
var proximityCollision = new CollisionState2D();
// Check below
if (FlagsHelper.IsSet(mask, Direction2D.DOWN))
{
proximityCollision.Below = CheckBelow(distance, data.skinWidth);
}
// Check above
if (FlagsHelper.IsSet(mask, Direction2D.UP))
{
proximityCollision.Above = CheckAbove(distance, data.skinWidth);
}
// Check right.
if (FlagsHelper.IsSet(mask, Direction2D.RIGHT))
{
proximityCollision.Right = CheckRight(distance, data.skinWidth);
}
// Check left
if (FlagsHelper.IsSet(mask, Direction2D.LEFT))
{
proximityCollision.Left = CheckLeft(distance, data.skinWidth);
}
return(proximityCollision);
}
public bool ValidateServerCertificate(
object sender,
X509Certificate certificate,
X509Chain chain,
SslPolicyErrors sslPolicyErrors)
{
if (sslPolicyErrors == SslPolicyErrors.None)
{
return(true);
}
txtTerminal.AppendText(">>>>>>>> SSL ERROR <<<<<<<<<");
txtTerminal.AppendText(Environment.NewLine);
var msg = new StringBuilder();
msg.AppendLine("Ssl Policy Errors!");
if (FlagsHelper.IsSet(sslPolicyErrors, SslPolicyErrors.RemoteCertificateChainErrors))
{
msg.AppendLine("Remote certificate chain cannot be verified.");
}
if (FlagsHelper.IsSet(sslPolicyErrors, SslPolicyErrors.RemoteCertificateNameMismatch))
{
msg.AppendLine("Remote certificate name mismatch.");
}
if (FlagsHelper.IsSet(sslPolicyErrors, SslPolicyErrors.RemoteCertificateNotAvailable))
{
msg.AppendLine("Remote certificate not available.");
}
MessageBoxResult result = System.Windows.MessageBox.Show(msg.ToString(), "Warning", MessageBoxButton.YesNo,
MessageBoxImage.Warning);
return(result == MessageBoxResult.Yes);
}
public void ApplyRectTransform(ViewElementTransform viewElementTransform, RectTransformFlag?overrideFlag = null)
{
var currentFlag = overrideFlag.HasValue ? overrideFlag.Value : viewElementTransform.rectTransformFlag;
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.SizeDelta))
{
rectTransform.sizeDelta = viewElementTransform.rectTransformData.sizeDelta;
}
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.AnchoredPosition))
{
rectTransform.anchoredPosition3D = viewElementTransform.rectTransformData.anchoredPosition;
}
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.AnchorMax))
{
rectTransform.anchorMax = viewElementTransform.rectTransformData.anchorMax;
}
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.AnchorMin))
{
rectTransform.anchorMin = viewElementTransform.rectTransformData.anchorMin;
}
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.LocalEulerAngles))
{
rectTransform.localEulerAngles = viewElementTransform.rectTransformData.localEulerAngles;
}
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.LocalScale))
{
rectTransform.localScale = viewElementTransform.rectTransformData.localScale;
}
if (FlagsHelper.IsSet(currentFlag, RectTransformFlag.Pivot))
{
rectTransform.pivot = viewElementTransform.rectTransformData.pivot;
}
}
/// <summary>
/// Writes a header line for each header flag that is specified in Headers
/// </summary>
protected virtual void WriteHeaders(bool flagEntry)
{
StackFrame frame = new StackFrame(_stackFramesToSkip, true);
if (!_hasWrittenDescriptor)
{
_hasWrittenDescriptor = true;
base.WriteLine("#===============================================================================");
base.WriteLine("# Log file starting...");
base.WriteLine("# This file contains diagnostic information.");
base.WriteLine("# Please do not edit this file.");
base.WriteLine(string.Format("# {0} at {1}", DateTime.Now.ToLongDateString(), DateTime.Now.ToLongTimeString()));
base.WriteLine("#===============================================================================");
}
base.WriteLine(string.Empty);
foreach (object header in _headerValues)
{
if (FlagsHelper.IsFlagSet((int)_headers, (int)header))
{
string headerName = this.GetHeaderDescription((InstanceTraceListenerHeaders)header);
string headerValue = this.GetHeaderValue((InstanceTraceListenerHeaders)header, frame);
string line = this.FormatHeaderLine(flagEntry, headerName, headerValue);
base.WriteLine(line);
}
}
base.Write(this.GetFlag(flagEntry) /* + ">" */);
}
private string GetShapeAndSize(RadialGradient gradient)
{
if (gradient.RadiusX > -1 && gradient.RadiusY > -1)
{
var radiusX = FlagsHelper.IsSet(gradient.Flags, RadialGradientFlags.WidthProportional)
? $"{gradient.RadiusX * 100}%"
: $"{gradient.RadiusX}px";
var radiusY = FlagsHelper.IsSet(gradient.Flags, RadialGradientFlags.HeightProportional)
? $"{gradient.RadiusY * 100}%"
: $"{gradient.RadiusY}px";
return($"ellipse {radiusX} {radiusY}");
}
var shape = gradient.Shape.ToString().ToLower();
var size = gradient.Size switch
{
RadialGradientSize.ClosestSide => "closest-side",
RadialGradientSize.ClosestCorner => "closest-corner",
RadialGradientSize.FarthestSide => "farthest-side",
_ => "farthest-corner"
};
return($"{shape} {size}");
}
void OnTriggerEnter2D(Collider2D coll)
{
if (FlagsHelper.IsSet(Ships.value, Mathf.RoundToInt(Mathf.Pow(2, coll.gameObject.layer))) && firedFrom != coll.transform.root.gameObject && !hasHit)
{
hit(coll);
}
}
void Update()
{
//to stop new colliders changing the center of mass
GetComponent <Rigidbody2D>().centerOfMass = Vector2.zero;
if (!FlagsHelper.IsSet <BallStatus>(status, BallStatus.FROZEN))
{
object contr;
if (!Settings.TryGetSetting(Settings.SettingName.MOVCONTROLS, out contr))
{
movControls = Settings.ControlType.MOUSE;
Debug.Log("Couldn't load move controls");
}
else
{
movControls = (Settings.ControlType)contr;
}
if (movControls == Settings.ControlType.MOUSE)
{
//move towards the mouse
mousePos = Util.MouseToWorldPos(0);
if (Vector2.Distance(mousePos, transform.position) >= 2)
{
GetComponent <Rigidbody2D>().velocity = (mousePos - transform.position).normalized * speed;
}
else
{
GetComponent <Rigidbody2D>().velocity = Vector2.zero;
transform.position = mousePos;
}
}
else
{
//use the keyboard
GetComponent <Rigidbody2D>().velocity = new Vector3(Input.GetAxis("Horizontal") * speed, Input.GetAxis("Vertical") * speed);
}
}
if (bombsEnabled && Input.GetButtonDown("Bomb"))
{
FireBomb();
}
//spin left or right
if (!FlagsHelper.IsSet <BallStatus>(status, BallStatus.SHOCKED))
{
rotAngle = Mathf.Repeat(rotAngle + Input.GetAxisRaw("Spin") * rotSpeed * Time.deltaTime, 360);
transform.rotation = Quaternion.AngleAxis(rotAngle, Vector3.forward);
//rigidbody2D.angularVelocity += new Vector3(0,0,rigidbody2D.velocity.x + rigidbody2D.velocity.y)*-0.1f;
}
//reduce the size of the halo
halo.localScale = new Vector3(Mathf.Clamp(halo.localScale.x - haloDecrement * Time.deltaTime, 0, 1), Mathf.Clamp(halo.localScale.x - haloDecrement * Time.deltaTime, 0, 1));
Debug.DrawLine(transform.position, (Vector2)transform.position + GetComponent <Rigidbody2D>().velocity, Color.blue, 0f);
}
public void RemoveStatus(BallStatus newStatus, Material toRemove)
{
FlagsHelper.Unset <BallStatus>(ref status, newStatus);
if (toRemove != null && matQueue.Remove(toRemove))
{
CheckStatus();
}
}
// Handlers
public void HandleLimbAttached(Limb skeletonLimbs, Limb attachedLimb)
{
if (FlagsHelper.IsSet(skeletonLimbs, Limb.HAND | Limb.BODY, Logical.AND))
{
skeleton.hand.entity.SetPosition(skeleton.body.entity.Position);
skeleton.SetActive(Limb.HAND, true);
}
}
// Private
private PlayerSkeleton AttachLimb(Limb limb)
{
FlagsHelper.Set(ref existing, limb);
SetActive(limb, true);
Events.Raise(OnLimbAttached, existing, limb);
return(this);
}
public void RemoveStatus(BallStatus newStatus, Material toRemove)
{
FlagsHelper.Unset <BallStatus>(ref status, newStatus);
if (toRemove != null && matQueue.Remove(toRemove))
{
CheckStatus();
}
AttachedBall.RemoveStatusAllAttachedBalls(transform, newStatus, toRemove);
}
private (bool, Size) GeRadius(CssReader reader, RadialGradientShape shape, ref RadialGradientFlags flags)
{
if (reader.CanRead)
{
var size = Dimensions.Zero;
if (shape == RadialGradientShape.Circle)
{
var radiusToken = reader.Read();
var isRadius = OffsetConverter.TryExtractOffset(radiusToken, out var radius);
if (isRadius)
{
size = new Dimensions(radius, radius);
reader.MoveNext();
}
}
if (shape == RadialGradientShape.Ellipse)
{
var radiusHToken = reader.Read();
var radiusVToken = reader.ReadNext();
var isRadiusH = OffsetConverter.TryExtractOffset(radiusHToken, out var radiusH);
var isRadiusV = OffsetConverter.TryExtractOffset(radiusVToken, out var radiusV);
if (isRadiusH && isRadiusV)
{
size = new Dimensions(radiusH, radiusV);
reader.MoveNext();
}
else
{
// Revert radiusVToken
reader.Rollback();
}
}
if (size != Dimensions.Zero)
{
if (size.Width.Type == OffsetType.Proportional)
{
FlagsHelper.Set(ref flags, WidthProportional);
}
if (size.Height.Type == OffsetType.Proportional)
{
FlagsHelper.Set(ref flags, HeightProportional);
}
return(true, new Size(size.Width.Value, size.Height.Value));
}
}
// Value -1 means undefined for RadialGradientShader
return(false, new Size(-1, -1));
}
public override string ToString()
{
var rightStr = FlagsHelper.IsSet(direction.Flags, Direction2D.RIGHT);
var leftStr = FlagsHelper.IsSet(direction.Flags, Direction2D.LEFT);
var upStr = FlagsHelper.IsSet(direction.Flags, Direction2D.UP);
var downStr = FlagsHelper.IsSet(direction.Flags, Direction2D.DOWN);
return(string.Format("[CharacterCollisionState2D] r: {0}, l: {1}, a: {2}, b: {3}, movingDownSlope: {4}, angle: {5}, becameGroundedThisFrame: {6}",
rightStr, leftStr, upStr, downStr, movingDownSlope, slopeAngle, becameGroundedThisFrame));
}
public void GetShocked(float duration, Material shockedMat)
{
if (!FlagsHelper.IsSet <BallStatus>(status, BallStatus.SHOCKED))
{
GetComponent <Renderer>().sharedMaterial = shockedMat;
AddStatus(BallStatus.SHOCKED, shockedMat);
AttachedBall.AddStatusAllAttachedBalls(transform, BallStatus.SHOCKED, shockedMat);
StartCoroutine(Timers.Countdown(duration, () => RemoveStatus(BallStatus.SHOCKED, shockedMat)));
}
}
public void AddStatus(BallStatus newStatus, Material newMat)
{
if (newMat != null)
{
GetComponent <Renderer>().sharedMaterial = newMat;
matQueue.Add(newMat);
}
FlagsHelper.Set <BallStatus>(ref status, newStatus);
CheckStatus();
}
/// <summary>
/// Sets a bit flag to a file attribute.
/// </summary>
/// <param name="user"></param>
/// <param name="attrib"></param>
/// <param name="value"></param>
public void SetWin32Attribute(FileAttributes attrib, bool value)
{
if (value)
{
Win32FileAttribute = (int)FlagsHelper.Set(((FileAttributes)Win32FileAttribute), attrib);
}
else
{
Win32FileAttribute = (int)FlagsHelper.Unset(((FileAttributes)Win32FileAttribute), attrib);
}
}
public bool IsCollisionBuffered(Direction2D direction)
{
var result = false;
foreach (CollisionState2D collisionState in collisionBuffer)
{
result |= FlagsHelper.IsSet(collisionState.direction.Flags, direction);
}
return(result);
}
//Removes a Layer that this object could collide with
public void RemoveFromCollisions(string layerName)
{
FlagsHelper.Unset(ref collisionLayerMask, 1 << LayerMask.NameToLayer(layerName));
FlagsHelper.Unset(ref collisionLayerMaskDown, 1 << LayerMask.NameToLayer(layerName));
//Handle Terrain and PassThroughBottom at the same time for ease of use
if (layerName == "Terrain")
{
FlagsHelper.Unset(ref collisionLayerMaskDown, 1 << LayerMask.NameToLayer("PassThroughBottom"));
}
}
private void HandleLimbActivationChange(bool isActive, Limb limb)
{
if (isActive)
{
FlagsHelper.Set(ref active, limb);
}
else
{
FlagsHelper.Unset(ref active, limb);
}
}
public void UpdateStateObjects()
{
if (OWInput.GetInputMode() == InputMode.None)
{
return;
}
FlashLight?.UpdateState(FlagsHelper.IsSet(State, State.Flashlight));
Translator?.ChangeEquipState(FlagsHelper.IsSet(State, State.Translator));
ProbeLauncher?.ChangeEquipState(FlagsHelper.IsSet(State, State.ProbeLauncher));
Signalscope?.ChangeEquipState(FlagsHelper.IsSet(State, State.Signalscope));
PlayerRegistry.GetSyncObject <AnimationSync>(NetId)?.SetSuitState(FlagsHelper.IsSet(State, State.Suit));
}
public void UpdateStateObjects()
{
if (OWInput.GetInputMode() == InputMode.None)
{
return;
}
FlashLight?.UpdateState(FlagsHelper.IsSet(State, State.Flashlight));
Translator?.ChangeEquipState(FlagsHelper.IsSet(State, State.Translator));
ProbeLauncher?.ChangeEquipState(FlagsHelper.IsSet(State, State.ProbeLauncher));
Signalscope?.ChangeEquipState(FlagsHelper.IsSet(State, State.Signalscope));
QSBCore.UnityEvents.RunWhen(() => QSBPlayerManager.GetSyncObject <AnimationSync>(PlayerId) != null,
() => QSBPlayerManager.GetSyncObject <AnimationSync>(PlayerId).SetSuitState(FlagsHelper.IsSet(State, State.Suit)));
}
public float GetAccessCost(AccessType accessMethod)
{
AccessCost ac = AccessCosts.Find(p => FlagsHelper.IsSet(p.Type, accessMethod));
if (ac != null)
{
return(ac.Cost);
}
else
{
return(Mathf.Infinity);
}
}
private string GetPosition(RadialGradient gradient)
{
var center = gradient.Center;
var posX = FlagsHelper.IsSet(gradient.Flags, RadialGradientFlags.XProportional)
? $"{center.X * 100}%"
: $"{center.X}px";
var posY = FlagsHelper.IsSet(gradient.Flags, RadialGradientFlags.YProportional)
? $"{center.Y * 100}%"
: $"{center.Y}px";
return($"at {posX} {posY}");
}
public void UpdateState(State state, bool value)
{
var states = State;
if (value)
{
FlagsHelper.Set(ref states, state);
}
else
{
FlagsHelper.Unset(ref states, state);
}
State = states;
}
public void GetFrozen(float duration, Material frozenMat)
{
if (!FlagsHelper.IsSet <BallStatus>(status, BallStatus.FROZEN))
{
GetComponent <Renderer>().sharedMaterial = frozenMat;
AddStatus(BallStatus.FROZEN, frozenMat);
GetComponent <Rigidbody2D>().velocity = Vector2.zero;
GetComponent <Rigidbody2D>().isKinematic = true;
AttachedBall.AddStatusAllAttachedBalls(transform, BallStatus.FROZEN, frozenMat);
StartCoroutine(Timers.Countdown(duration, () => {
RemoveStatus(BallStatus.FROZEN, frozenMat);
GetComponent <Rigidbody2D>().isKinematic = false;
}));
}
}
public static bool ComboValid(Transform parent, Transform child)
{
AttachedBall childBall = child.GetComponent <AttachedBall>();
AttachedBall parentBall = parent.GetComponent <AttachedBall>();
if (childBall != null && parentBall != null)
{
return(!FlagsHelper.IsSet(childBall.status, BallStatus.INFECTED) && !FlagsHelper.IsSet(parentBall.status, BallStatus.INFECTED) &&
(childBall.type == AttachedBall.BallTypeNames.BonusBall || parentBall.type == AttachedBall.BallTypeNames.BonusBall ||
childBall.type == parentBall.type));
}
else
{
return(false);
}
}
/// <summary>
/// Binds data contexts ASAP to prevent flickering.
/// </summary>
public MainWindow()
{
InitializeComponent();
UpdateSettings(); // migrate settings over from older Priceall version
Task.Run(async() => { await FlagsHelper.CheckAllFlags(); }); // update flag values in settings
DataContext = _styleBinding;
AppraisalInfo.DataContext = _infoBinding;
AppraisalControls.DataContext = _controlsBinding;
// subscribe settings events
Instance.AutoRefreshToggled += ToggleAutoRefresh;
Instance.PriceColorChanged += RefreshPriceColor;
Instance.QueryHotkeyUpdated += UpdateQueryHotkey;
Instance.SettingsReset += ResetSettings;
}
/// <summary>
/// Sets a bit flag to a file attribute.
/// </summary>
/// <param name="user"></param>
/// <param name="attrib"></param>
/// <param name="value"></param>
public void SetWin32Attribute(Principal user, FileAttributes attrib, bool value)
{
using (var context = new OnlineFilesEntities())
if (!(context.FileSecurities.Where(d => d.fk_FileId == pk_FileId).ToList().Any(x => user.UserProfile.mySecurityGroups.Contains(x.SecurityObjectId) && x.canWrite)))
{
throw new SecurityException("Not Authorized.");
}
if (value)
{
Win32FileAttribute = (int)FlagsHelper.Set(((FileAttributes)Win32FileAttribute), attrib);
}
else
{
Win32FileAttribute = (int)FlagsHelper.Unset(((FileAttributes)Win32FileAttribute), attrib);
}
}
