public async Task OpenAsync(string correlationId)
{
var components = _references.GetAll();
Referencer.SetReferences(this, components);
await Opener.OpenAsync(correlationId, components);
}
public async Task <IActionResult> PutReferencer(int id, Referencer referencer)
{
if (id != referencer.IdTag)
{
return(BadRequest());
}
_context.Entry(referencer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReferencerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Puts a new reference into this reference map.
/// </summary>
/// <param name="locator">a locator to find the reference by.</param>
/// <param name="component">a component reference to be added.</param>
public override void Put(object locator, object component)
{
base.Put(locator, component);
if (_opened)
{
Referencer.SetReferencesForOne(ParentReferences, component);
}
}
/// <summary>
/// close all references as an asynchronous operation.
/// </summary>
/// <param name="correlationId">a unique transaction id to trace calls across components</param>
/// <returns>Task.</returns>
public async Task CloseAsync(string correlationId)
{
var components = _references.GetAll();
await Closer.CloseAsync(correlationId, components);
Referencer.UnsetReferences(components);
_references.Clear();
}
/// <summary>
/// Checks whether the provided entity is stored in the corresponding data store.
/// </summary>
/// <param name="entity">The entity to look for in the corresponding data store.</param>
/// <returns>A boolean value indicating whether the entity was found.</returns>
public override bool IsStored(IEntity entity)
{
bool isStored = false;
using (LogGroup logGroup = LogGroup.StartDebug("Checking whether the provided entity has already been stored."))
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
LogWriter.Debug("Entity type: " + entity.GetType());
if (EntitiesUtilities.IsReference(entity.GetType()))
{
LogWriter.Debug("Is reference == true");
EntityReference reference = (EntityReference)entity;
Type type = EntityState.GetType(reference.Type1Name);
Type type2 = EntityState.GetType(reference.Type2Name);
LogWriter.Debug("Type 1: " + type.ToString());
LogWriter.Debug("Type 2: " + type2.ToString());
if (Stores[entity].IsStored(entity))
{
LogWriter.Debug("Reference object found in store.");
isStored = true;
}
else
{
LogWriter.Debug("Reference object NOT found. Checking for one with matching properties.");
isStored = Referencer.MatchReference(
type,
reference.Entity1ID,
reference.Property1Name,
type2,
reference.Entity2ID,
reference.Property2Name);
}
}
else
{
LogWriter.Debug("Is reference != true");
isStored = Stores[entity].IsStored(entity);
}
}
LogWriter.Debug("Is stored: " + isStored.ToString());
return(isStored);
}
/// <summary>
/// Removes a previously added reference that matches specified locator. If many
/// references match the locator, it removes only the first one.When all
/// references shall be removed, use removeAll() method instead.
/// </summary>
/// <param name="locator">a locator to remove reference</param>
/// <returns>the removed component reference.</returns>
public override object Remove(object locator)
{
var component = base.Remove(locator);
if (_opened)
{
Referencer.UnsetReferencesForOne(component);
}
return(component);
}
/// <summary>
/// Closes component and frees used resources.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
public async Task CloseAsync(string correlationId)
{
if (_opened)
{
_opened = false;
var components = base.GetAll();
Referencer.UnsetReferences(components);
}
await Task.Delay(0);
}
/// <summary>
/// true if the component has been opened and false otherwise.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
public async Task OpenAsync(string correlationId)
{
if (!_opened)
{
_opened = true;
var components = base.GetAll();
Referencer.SetReferences(this.ParentReferences, components);
}
await Task.Delay(0);
}
/// <summary>
/// Removes all component references that match the specified locator.
/// </summary>
/// <param name="locator">the locator to remove references by.</param>
/// <returns>a list, containing all removed references.</returns>
public override List <object> RemoveAll(object locator)
{
var components = base.RemoveAll(locator);
if (_opened)
{
Referencer.UnsetReferences(components);
}
return(components);
}
private void Start()
{
foreach (Transform child in weaponHolder.swordHolder)
{
child.gameObject.SetActive(true);
if (child.tag == ConstantHandler.WEAPON_TAG)
{
Referencer referencer = child.GetComponent <Referencer>();
referencer.gameObject.SetActive(false);
}
}
}
// This script is don't destroy on load (handled by gamestate via gameobject)
// Pre-initialization
private void Awake()
{
if (instance == null)
{
instance = this;
RegisterPlayer();
RegisterScene();
RegisterHUDUI();
}
else if (instance != this)
{
Debug.LogError("Uh oh! Someone tried to create multiple instances of the master referencer!");
}
}
// Start is called before the first frame update
void loadReferences()
{
Referencer referencer = GameObject.FindGameObjectWithTag("Referencer").GetComponent <Referencer>();
currencyCounter = referencer.currencyCounter;
velocityText = referencer.velocityText;
posText = referencer.positionText;
crossHair = referencer.CrossHair;
progressText = referencer.progressText;
countDownText = referencer.countDown;
leaderBoardMenu = referencer.leaderBoardMenu;
leaderBoardListingTransform = referencer.leaderBoardListingTransform;
messagePanel = referencer.messagePanel;
boostTimer = referencer.boostTimer;
upsideDownText = referencer.upsideDownText;
}
private void Update()
{
if (PlayerUI.singleton.isPanel || PlayerUI.singleton.isCutscene)
{
return;
}
if (currentWeapon == null)
{
return;
}
foreach (Transform child in weaponHolder.swordHolder)
{
if (child.tag == ConstantHandler.WEAPON_TAG)
{
if (child.name.ToUpper() == currentWeapon.name.ToUpper())
{
child.gameObject.SetActive(true);
currentWeaponRef = child.GetComponent <Referencer>();
}
else
{
child.gameObject.SetActive(false);
}
}
}
if (Input.GetKey(KeyHandler.BlockKey) && !isAttacking)
{
Block();
}
else
{
Unblock();
}
if (Input.GetKeyDown(KeyHandler.AttackKey) && !isAttacking && !isBlocking)
{
if (currentWeapon.weaponType == WeaponType.Sword)
{
StartCoroutine(StartSwordAttack());
}
}
}
private async Task RunAsync(string correlationId, CancellationToken token)
{
_correlationId = correlationId;
CaptureErrors();
//await StartAsync(correlationId, token);
if (_config == null)
{
throw new InvalidStateException(correlationId, "NO_CONFIG", "Container was not configured");
}
try
{
_logger.Trace(correlationId, "Starting container.");
// Create references with configured components
InitReferences(_references);
_references.PutFromConfig(_config);
// Reference and open components
var components = _references.GetAll();
Referencer.SetReferences(_references, components);
await Opener.OpenAsync(correlationId, _references.GetAll());
// Get reference to logger
_logger = new CompositeLogger(_references);
// Get reference to container info
var infoDescriptor = new Descriptor("*", "container-info", "*", "*", "*");
_info = (ContextInfo)_references.GetOneRequired(infoDescriptor);
_logger.Info(correlationId, "Container {0} started.", _info.Name);
}
catch (Exception ex)
{
_references = null;
_logger.Error(correlationId, ex, "Failed to start container");
throw;
}
}
public async Task <ActionResult <Referencer> > PostReferencer(Referencer referencer)
{
_context.Referencer.Add(referencer);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ReferencerExists(referencer.IdTag))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetReferencer", new { id = referencer.IdTag }, referencer));
}
public async Task StartAsync(string correlationId, CancellationToken token)
{
if (Config == null)
{
throw new InvalidStateException(correlationId, "NO_CONFIG", "Container was not configured");
}
try
{
Logger.Trace(correlationId, "Starting container.");
// Create references with configured components
InitReferences(References);
References.PutFromConfig(Config);
// Reference and open components
var components = References.GetAll();
Referencer.SetReferences(References, components);
await Opener.OpenAsync(correlationId, References.GetAll());
// Get reference to logger
Logger = new CompositeLogger(References);
// Get reference to container info
var infoDescriptor = new Descriptor("*", "container-info", "*", "*", "*");
Info = (ContainerInfo)References.GetOneRequired(infoDescriptor);
Logger.Info(correlationId, "Container {0} started.", Info.Name);
}
catch (Exception ex)
{
References = null;
Logger.Error(correlationId, ex, "Failed to start container");
throw;
}
}
