public override IActionResult Delete(int id)
{
var entity = EntityRepository.GetEntityByType <CustomEntity>().Find(id);
if (entity == null)
{
return(NotFound());
}
var isOwnedByCustomEntity = !StaticUtilities.NotCustomEntityTheOwningEntity(entity);
EntityRepository.Db.Remove(entity);
EntityRepository.SaveChanges();
EntityRepository.Db.RecordedActivities.Add(new RecordedActivity(
Name: ActivityOperation.Delete.ToString(),
description: $"Deleted a new entity '{entity.GetOwningEntityType()}'",
user: GetUser(HttpContext.User),
tag: entity.ToStr(),
details: $"Deleted new entity {entity.Name}",
atTime: DateTimeOffset.UtcNow,
owningEntityId: isOwnedByCustomEntity ? entity.OwningCustomEntity.Id : entity.OwningEntityId,
owningEntityType: isOwnedByCustomEntity ? EntityType.CustomType : entity.OwningEntityType));
EntityRepository.SaveChanges();
return(new NoContentResult());
}
private void Update()
{
if (IsTripleTouch)
{
OnTripleTouch?.Invoke();
return;
}
if (StaticUtilities.IsPointerOverUIObject())
{
return;
}
var inputPosition = Input.mousePosition;
if (IsPressed)
{
OnPress?.Invoke(inputPosition);
}
if (IsDrag)
{
OnDrag?.Invoke(inputPosition);
}
if (IsReleased)
{
OnRelease?.Invoke();
}
}
//------------------------------------------------------------------------+
// TextBox_LostFocus |
//------------------------------------------------------------------------+
private void TextBox_LostFocus(object sender, RoutedEventArgs e)
{
string IDNodo;
XmlNode node;
IDNodo =
(
(XmlAttribute)
(
(
(System.Windows.Controls.CheckBox)
(
(
(StackPanel)(((TextBox)(sender)).Parent)
).Children[1]
)
).Tag
)
).Value.ToString();
node = _xTXP.Document.SelectSingleNode("//Node[@ID='" + IDNodo + "']");
if (node != null)
{
if (node.Attributes["NotaTDL"] == null)
{
XmlAttribute attr = node.OwnerDocument.CreateAttribute("NotaTDL");
node.Attributes.Append(attr);
}
node.Attributes["NotaTDL"].Value = ((TextBox)(sender)).Text;
StaticUtilities.MarkNodeAsModified(node, App.OBJ_MOD); _isModified = true;
}
//_xTXP.Save();
}
public void BuildRun()
{
var g = (Instantiate(GameManager) as GameObject).GetComponent <PlayerStatManager>();
if (isArcade)
{
thisArcadeRun = new int[numberOfLevels];
var temp = StaticUtilities.ShuffleList(AllLevelsBySceneNumber);
for (int i = 0; i < numberOfLevels; i++)
{
thisArcadeRun[i] = temp[i];
}
g.Levels = thisArcadeRun;
g.numberOfPlayers = isTwoPlayer ? 2 : 1;
g.LoadNextLevel();
}
else
{
numberOfLevels = Mathf.Clamp(numberOfLevels, 1, 3);
thisVersusRun = new int[numberOfLevels];
var temp = StaticUtilities.ShuffleList(VersusLevels);
for (int i = 0; i < numberOfLevels; i++)
{
thisVersusRun[i] = temp[i];
}
g.Levels = thisVersusRun;
g.numberOfPlayers = 2;
g.LoadNextLevel();
}
}
IEnumerator Strafe()
{
//Debug.Log("readying to fire");
AssessTarget();
if (Target == null)
{
yield return(0);
}
var p = Target.transform.position;
transform.up = aim();
Speed = MaxSpeed * 1.15f;
float t = Vector2.Distance(p, transform.position) * 0.5f;
t /= getDV();
yield return(StartCoroutine(StaticUtilities.Wait(t)));
AssessTarget();
if (Target == null)
{
yield return(0);
}
fire();
disengage();
yield return(StartCoroutine(StaticUtilities.Wait(t * 3)));
isAttacking = false;
}
//------------------------------------------------------------------------+
// buttonbuttonAzzeraValori_Click |
//------------------------------------------------------------------------+
private void buttonbuttonAzzeraValori_Click(object sender, RoutedEventArgs e)
{
//_xTXP.Save();
foreach (XmlNode item in _xTXP.Document.SelectNodes("//Node"))
{
if (item.Attributes["Checked"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("Checked");
item.Attributes.Append(attr);
}
item.Attributes["Checked"].Value = "False";
if (item.Attributes["NotaTDL"] == null)
{
XmlAttribute attr = _xTXP.Document.CreateAttribute("NotaTDL");
item.Attributes.Append(attr);
}
item.Attributes["NotaTDL"].Value = "";
StaticUtilities.MarkNodeAsModified(item, App.OBJ_MOD); _isModified = true;
}
RevisoftApplication.XmlManager x = new XmlManager();
x.TipoCodifica = RevisoftApplication.XmlManager.TipologiaCodifica.Normale;
_xTXP.isModified = _isModified; _xTXP.Save(_isModified);
_isModified = false;
TreeXmlProvider.Document = x.LoadEncodedFile(_xTXP.File);
TreeXmlProvider.Refresh();
LoadDataSource();
}
private void Update()
{
if (target != null)
{
if (!darknessLock)
{
darknessLock = true;
}
if (target == null)
{
if (!gm.GetService <LightsController>().lightsOn)
{
darknessLock = false;
}
}
if (StaticUtilities.CheckIdentity <RatbagPlayerBrain>(target))
{
Vector2 targetFacingDirection = target.GetComponent <FaceDirection>().direction;
if (bouncerFacingDirection == targetFacingDirection)
{
Charge(chargeSpeed);
// print("charge firing: " + chargeSpeed);
for (int i = 0; i < componentsToUpdate.Length; i++)
{
IChargeUpdatable componentToUpdate = componentsToUpdate[i];
componentToUpdate.OnBouncerCharge();
}
}
}
}
}
void Update()
{
AnimatedTvariable();
if (searching)
{
if (gm.GetService <LightsController>().lightsOn)
{
CastSearchingRay();
if (searchRayResult.collider != null)
{
Collider2D col = searchRayResult.collider;
if (StaticUtilities.CheckIdentity <Ground>(col.gameObject))
{
return;
}
if (StaticUtilities.CheckIdentity <RatbagPlayerBrain>(col.gameObject))
{
foreach (ITargetUpdatable targetter in targettingComponents)
{
targetter.TargetFound(col.gameObject);
}
}
}
}
}
}
private void Start()
{
groundedMovables = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IGroundedMovable>(gameObject);
movableComponents = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IMovable>(gameObject);
SetUpGroundedMoveInterface();
SetUpMoveInterface();
}
// private float temp;
void OnEnable()
{
audioLib = StaticUtilities.ReturnDefaultAudioLibrary();
defaultPlayerBrain = FindObjectOfType <RatbagPlayerBrain>();
thisScene = SceneManager.GetActiveScene();
}
private void SetUpKnockInterface()
{
knockTargetsComponents = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IKnockTarget>(gameObject);
foreach (var knockTarget in knockTargetsComponents)
{
knockTarget.OnKnockTarget += KnockingTheTarget;
}
}
protected void btnAddressByZIP_Click(object sender, EventArgs e)
{
if (StaticUtilities.IsAppSettingTrue("AddressByZipEnabled"))
{
var addressByZip = new AddressByZip(AddressByZipUrl, txtZIP.Text);
var addressByZipResult = JsonConvert.DeserializeObject <AddressByZipResult>(addressByZip.Execute());
lblStatus.Text = (addressByZipResult == null ? "Invalid" : "City: " + addressByZipResult.city + " State: " + addressByZipResult.state + " Country: " + addressByZipResult.country);
}
}
private void SetUp_ILightsUpdatables()
{
lightsUpdatables = StaticUtilities.ReturnInterfaceImplementationsFromScene <ILightsChange_Updatable>();
for (int i = 0; i < lightsUpdatables.Length; i++)
{
OnSwitchLights += lightsUpdatables[i].OnLightsChange;
}
}
public void TaskImplementation()
{
_logger.LogDebug("** Performing unzip task");
var localTemp = string.Empty;
localTemp = StaticUtilities.GetDataPath();
ZipFile.ExtractToDirectory(localTemp + "\\" + CurrentSessionParams.LocalDirName + "\\" + CurrentSessionParams.FileName + ".zip", localTemp + "\\" + CurrentSessionParams.LocalDirName, true);
}
private void InjectThisToStates()
{
var componentsThatNeedGM = StaticUtilities.FindInterfacesFromStatesSceneWide <IGM_ServiceLocator_Recievable>();
foreach (IGM_ServiceLocator_Recievable component in componentsThatNeedGM)
{
component.AssignGM(this);
}
}
private void SetUp_IGroundedUpdatables()
{
groundedUpdatables = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IGroundedUpdatable>(gameObject);
for (int i = 0; i < groundedUpdatables.Length; i++)
{
OnGroundedUpdate += groundedUpdatables[i].GroundedUpdate;
}
}
private void SetUpWeightingChangers()
{
weightingChangers = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IChangeableCameraTargetingWeight>(gameObject);
foreach (var changer in weightingChangers)
{
changer.ChangingCameraTargetWeight += ChangeWeighting;
}
}
void Start()
{
jumpingComponents = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IJump>(gameObject);
foreach (var jump in jumpingComponents)
{
jump.OnJump += DoAJump;
}
}
private RaycastHit2D CastLeftSearchingRay()
{
float lerpAngleLeft = Mathf.LerpAngle(vecLeftUp_Angle, vecLeftDown_Angle, t);
Vector2 lerpVectorLeft = StaticUtilities.Vector2FromAngle(lerpAngleLeft);
Debug.DrawRay(transform.position, lerpVectorLeft * searchRange, Color.magenta, .01f);
return(Physics2D.Raycast(transform.position, lerpVectorLeft, searchRange, targetLayerMask));
}
private void SetUpLevelCompleteInterfaces()
{
mainLevelCompleteUpdatables = StaticUtilities.ReturnInterfaceImplementationsFromScene <IMainLevelComplete_Updateable>();
for (int i = 0; i < mainLevelCompleteUpdatables.Length; i++)
{
OnLevelComplete += mainLevelCompleteUpdatables[i].OnMainLevelComplete;
}
}
private void SetUpReigniters()
{
reigniters = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IDarknessReignitable>(gameObject);
foreach (var ignite in reigniters)
{
ignite.ReigniteRenderer += Reignite;
}
}
public BallMatchableData(uint number)
{
int index = StaticUtilities.GetPowerOfTwo(number) - 1;
var data = GameManager.Instance.DataBase.BallData.GetData(index);
criteria = data.Criteria;
color = data.Color;
localScale = data.LocalScale;
IsMatched = false;
}
void OnEnable()
{
lockInput = false;
controllers = StaticUtilities.ReturnOnlyActiveControllers <IPlayerInput2D>(GetComponents <IPlayerInput2D>(), this);
if (controllers == null)
{
StaticUtilities.NoControllerFound();
}
}
protected void btn_Click(object sender, EventArgs e)
{
if (StaticUtilities.IsAppSettingTrue("ZipPlus4Enabled"))
{
VerifyAddressZipPlus4 = new VerifyAddressZipPlus4(ZipPlus4Url, ZipPlus4AuthId, ZipPlus4AuthToken, txtStreet.Text, txtCity.Text, txtState.Text, txtZIP.Text);
string rawResponse = VerifyAddressZipPlus4.Execute();
var candidates = JsonConvert.DeserializeObject <CandidateAddress[]>(rawResponse);
lblStatus.Text = (candidates.Length == 0 ? "Invalid" : "Latitude: " + candidates[0].Metadata.Latitude + " Longitude: " + candidates[0].Metadata.Longitude);
}
}
private void SetUpChangeDirectionInterfaces()
{
changeDirectionables = StaticUtilities.ReturnInterfacesFromComponentsAndAnyControllerStates <IChangeDirection>(gameObject);
for (int i = 0; i < changeDirectionables.Length; i++)
{
IChangeDirection controller = changeDirectionables[i];
controller.OnChangeDirection += ChangeDirection;
}
}
private void UpdateVolume()
{
float musicSliderValue = GetDataFromPrefs(musicVolumeParameter);
float fxSliderValue = GetDataFromPrefs(fxVolumeParameter);
float musicVolume = StaticUtilities.GetLogValueForMixer(musicSliderValue);
float fxVolume = StaticUtilities.GetLogValueForMixer(fxSliderValue);
mixer.SetFloat(musicVolumeParameter, musicVolume);
mixer.SetFloat(fxVolumeParameter, fxVolume);
}
void OnEnable()
{
var objs = StaticUtilities.ReturnInterfaceImplementationsFromScene <CrowdSounds>();
if (objs.Length > 1)
{
Destroy(this.gameObject);
}
DontDestroyOnLoad(this.gameObject);
}
void OnEnable()
{
audioLib = StaticUtilities.ReturnDefaultAudioLibrary();
playerResetters = StaticUtilities.ReturnOnlyActiveControllers <IPlayerResettable>(GetComponents <IPlayerResettable>(), this);
for (int i = 0; i < playerResetters.Length; i++)
{
playerResetters[i].OnPlayerReset += CallingGameReset;
}
}
public void ChangeColor(Color color)
{
var darkColor = StaticUtilities.ChangeColorBrightness(color, COLOR_CORRECTION_FACTOR);
var minMaxGradient = new ParticleSystem.MinMaxGradient(darkColor, color);
foreach (var mainModule in _mainModules)
{
var module = mainModule;
module.startColor = minMaxGradient;
}
}
public void OnEnterCollision(Collision2D col)
{
// Debug.Log("ground hit");
if (StaticUtilities.CheckIdentity <Ground>(col.gameObject))
{
if (!isLocked)
{
ratBrain.SetState(ratBrain.AvailableStates[typeof(UpAndActive)]);
}
}
}
