public void PerformNoiseAttack(Player target)
{
if (this.currAttackType == AttackType.None)
{
EnvironmentElement currEnvElement = gameManagerRef.getActiveEnvElement();
GameObject sound = GameObject.FindGameObjectWithTag("Audio");
AudioSource aux1 = sound.GetComponent <AudioSource>();
var aux = Resources.Load("Loud Noise") as AudioClip;
aux1.PlayOneShot(aux);
int damage = 10;
if (target.currAttackType == AttackType.Aerial || currEnvElement.GetType() == EnvElementType.Car)
{
damage = 0;
}
else if (currEnvElement.GetType() == EnvElementType.Girl)
{
this.AddReputation(10);
damage = 10;
}
else if (currEnvElement.GetType() == EnvElementType.Swagger)
{
this.RemoveReputation(10);
damage = 0;
}
this.currAttackType = AttackType.Noise;
isAttacking = true;
this.noiseAttackSprite.SetActive(true);
gameManagerRef.StartCoroutine(FinishAttack(noiseAttackSprite, damage, target));
}
}
public async Task <IPreparedEffect> PrepareEffectAsync(EnvironmentElement element, string descriptor, PlaybackOptions options)
{
CreateAudioFileInputNodeResult nodeResult;
AudioSample sample = await this.sync.GetElementByIdAsync <AudioSample> (descriptor).ConfigureAwait(false);
StorageFile file = await GetFileAsync(sample).ConfigureAwait(false);
AudioNodeEmitter emitter = null; // GetEmitter (options);
if (emitter != null)
{
nodeResult = await graph.CreateFileInputNodeAsync(file, emitter).ConfigureAwait(false);
}
else
{
nodeResult = await graph.CreateFileInputNodeAsync(file).ConfigureAwait(false);
}
var node = nodeResult.FileInputNode;
var prepared = new PreparedSource(node, emitter)
{
Duration = nodeResult.FileInputNode.Duration
};
/*
* node.FileCompleted += (o, e) => {
* OnElementFinished (new PreparedElementEventArgs (prepared));
* };*/
return(prepared);
}
// Start is called before the first frame update
void Start()
{
globalTimer = 100;
maxEnvElements = 1;
spawnChoiceTimeInSeconds = 5;
spawnProbability = 0.5f;
float maxLifeBarSize = 88.0f;
Global._players.Add(new Player(this, player1Sprite, UILifeBarObjectP1, maxLifeBarSize, spriteAerialLeft, spriteAerialFailLeft, spriteVerbalLeft, spriteBirdLeft, spriteNoiseLeft, 60));
Global._players.Add(new Player(this, player2Sprite, UILifeBarObjectP2, maxLifeBarSize, spriteAerialRight, spriteAerialFailRight, spriteVerbalRight, spriteBirdRight, spriteNoiseRight, 60));
possibleEnvElements = new List <EnvironmentElement>();
Vector3 initialPos = new Vector3(-1.16f, 2.05f, -0.58f);
Vector3 cameraOrientation = -camera.transform.forward;
Vector3 orientation = new Vector3(cameraOrientation.x, 0, cameraOrientation.z);
possibleEnvElements.Add(new EnvironmentElement(EnvElementType.Car, carPrefab, new Vector3(-1.16f, 1.45f, -0.58f), orientation, 40.0f, "Car"));
possibleEnvElements.Add(new EnvironmentElement(EnvElementType.Girl, girlPrefab, initialPos, orientation, 20.0f, "Girl"));
possibleEnvElements.Add(new EnvironmentElement(EnvElementType.Swagger, guyPrefab, initialPos, orientation, 20.0f, "Guy"));
activeEnvElement = ChooseNewEnvElement();
activeEnvElement.Spawn();
StartCoroutine(DecreaseGlobalTimer(1));
}
//attack methods
public void PerformAerialAttack(Player target)
{
if (this.currAttackType == AttackType.None)
{
bool success = IsSuccess();
if (success)
{
this.currAttackType = AttackType.Aerial;
GameObject randSprite = this.aerialAttackSprites[Random.Range(0, aerialAttackSprites.Count)];
randSprite.SetActive(true);
if (target.currAttackType == AttackType.Bird)
{
gameManagerRef.StartCoroutine(FinishAttack(randSprite, 0, target));
}
else
{
gameManagerRef.StartCoroutine(FinishAttack(randSprite, 10, target));
}
}
else
{
EnvironmentElement currEnvElement = gameManagerRef.getActiveEnvElement();
this.currAttackType = AttackType.AerialFail;
GameObject randSprite = this.aerialAttackFailSprites[Random.Range(0, aerialAttackFailSprites.Count)];
randSprite.SetActive(true);
gameManagerRef.StartCoroutine(FinishAttack(randSprite, 0, target));
if (currEnvElement.GetType() == EnvElementType.Car || currEnvElement.GetType() == EnvElementType.Girl || currEnvElement.GetType() == EnvElementType.Swagger)
{
this.RemoveReputation(10);
}
}
}
}
public override void OnInspectorGUI()
{
EnvironmentElement element = (EnvironmentElement)target;
if (GUILayout.Button("ApplyToTilemap", GUILayout.Width(200)))
{
if (element.tile != null)
{
element.tile.SetOccupied(false);
EditorUtility.SetDirty(element.tile);
}
Vector3 pos = element.transform.position;
pos.y -= 0.1f;
GameObject collider = M_GameHelper.SGetObjectAtWorldPoint(pos);
Tile tile = collider.transform.parent.gameObject.GetComponent <Tile>();
if (tile != null)
{
pos = tile.gameObject.transform.position;
pos.y = M_MapManager.SGetYDepthValue(pos.z);
element.transform.position = pos;
element.tile = tile;
tile.SetOccupied(true);
EditorUtility.SetDirty(element);
EditorUtility.SetDirty(element.tile);
}
}
}
public static EnvironmentElement GetEnvironmentElement(string name)
{
EnsureArg.IsNotNullOrWhiteSpace(name, nameof(name));
EnvironmentSection environmentSection = GetEnvironmentSection();
if (!environmentSection.Items.Exists(name))
{
return(null);
}
EnvironmentElement environment = environmentSection.Items[name] as EnvironmentElement;
return(environment);
}
public void SetupNext(EnvironmentElement element, IEnvironmentService service, Position nextPosition)
{
bool isFirst = IsFirst;
if (!isFirst && Component.Playlist.Repeat == SourceRepeatMode.None)
{
NextTime = default;
return;
}
string currentDescriptor = NextDescriptor;
NextDescriptor = GetNextDescriptor();
if (NextDescriptor == null)
{
return;
}
NextTime = (Component.Timing ?? element.Timing).GetNextTime(this.random, isFirst);
var options = new PlaybackOptions {
Position = nextPosition
};
if (currentDescriptor == NextDescriptor)
{
var left = CurrentEffect;
var right = NextPrepare?.Result;
CurrentEffect = right;
if (left != null)
{
NextPrepare = Task.FromResult(left);
}
else
{
NextPrepare = service.PrepareEffectAsync(element, NextDescriptor, options);
}
return;
}
else
{
CurrentEffect = NextPrepare?.Result;
}
// TODO: Cache preparations and add adjust playback to engine
NextPrepare = service.PrepareEffectAsync(element, NextDescriptor, options);
Trace.WriteLine($"{element.Name} next effect: {NextDescriptor} in {NextTime}");
}
public void PlayFirstElement()
{
const string elementId = "eID";
const string sourceId = "ID1";
var element = new EnvironmentElement {
Id = elementId,
Positioning = new Positioning {
FixedPosition = new Position()
},
Timing = new Timing {
MinStartDelay = TimeSpan.FromMinutes(0),
MaxStartDelay = TimeSpan.FromMinutes(0)
},
Audio = new AudioComponent {
Playlist = new ElementPlaylist {
Order = SourceOrder.InOrder,
Repeat = SourceRepeatMode.None,
Descriptors = new[] {
sourceId
}
}
}
};
var state = new EncounterStateElement {
ElementId = elementId,
StartsWithState = true
};
var audio = new Mock <IAudioService> ();
var storage = new Mock <ILocalStorageService> ();
var effect = new TestEffect(TimeSpan.FromSeconds(30));
audio.Setup(a => a.PrepareEffectAsync(It.IsAny <EnvironmentElement> (), It.IsAny <string> (), It.IsAny <PlaybackOptions> ()))
.ReturnsAsync(effect);
var environmentElement = new PlaybackEnvironmentElement(state, element);
environmentElement.Tick(new ActiveServices {
Audio = audio.Object,
Storage = storage.Object
});
audio.Verify(a => a.PrepareEffectAsync(element, sourceId, It.IsAny <PlaybackOptions> ()));
audio.Verify(a => a.PlayEffect(effect));
}
public PlaybackEnvironmentElement(EncounterStateElement stateElement, EnvironmentElement element)
{
StateElement = stateElement ?? throw new ArgumentNullException(nameof(stateElement));
Element = element ?? throw new ArgumentNullException(nameof(element));
IsActive = StateElement.StartsWithState;
Intensity = StateElement.Intensity;
foreach (EnvironmentComponent component in Element.GetComponents())
{
this.componentStates.Add(new ComponentState {
Component = component,
IsActive = stateElement.StartsWithState,
LastIntensity = stateElement.Intensity
});
}
}
public Task <IPreparedEffect> PrepareEffectAsync(EnvironmentElement element, string descriptor, PlaybackOptions options)
{
if (element is null)
{
throw new ArgumentNullException(nameof(element));
}
LightingComponent lighting = element.Lighting;
if (lighting == null)
{
return(Task.FromResult <IPreparedEffect> (null));
}
return(Task.FromResult <IPreparedEffect> (null));
}
public async Task <IReadOnlyList <FileSample> > EnsureElementPresentAsync(EnvironmentElement element, IProgress <double> progress = null, CancellationToken cancellationToken = default)
{
if (element is null)
{
throw new ArgumentNullException(nameof(element));
}
await this.loadedServices.ConfigureAwait(false);
List <Task> tasks = new List <Task> ();
List <FileSample> samples = new List <FileSample> ();
AggregateProgress totalProgress = (progress != null) ? new AggregateProgress(progress) : null;
if (element.Audio != null)
{
foreach (string sampleId in element.Audio.Playlist.Descriptors)
{
FileSample sample = (await this.sync.GetElementByIdAsync(sampleId).ConfigureAwait(false) as FileSample);
if (sample == null)
{
continue;
}
IProgress <double> nodeProgress = totalProgress?.CreateProgressNode();
samples.Add(sample);
tasks.Add(this.downloadManager.EnsurePresentAsync(sample, nodeProgress, cancellationToken));
}
}
totalProgress?.FinishDiscovery();
int offset = 0;
for (int i = 0; i < tasks.Count; i++)
{
try {
await tasks[i].ConfigureAwait(false);
} catch {
samples.RemoveAt(i - offset++);
}
}
return(samples);
}
public async Task <PlaybackEnvironment> PrepareEncounterStateAsync(EncounterState encounterState, IProgress <double> progress = null, CancellationToken cancellationToken = default)
{
if (encounterState is null)
{
throw new ArgumentNullException(nameof(encounterState));
}
await this.loadedServices.ConfigureAwait(false);
AggregateProgress totalProgress = (progress != null) ? new AggregateProgress(progress) : null;
var elements = new List <(EncounterStateElement, EnvironmentElement)> ();
var presentTasks = new List <Task <IReadOnlyList <FileSample> > > ();
foreach (EncounterStateElement stateElement in encounterState.EnvironmentElements)
{
EnvironmentElement element = await this.sync.GetElementByIdAsync <EnvironmentElement> (stateElement.ElementId).ConfigureAwait(false);
elements.Add((stateElement, element));
presentTasks.Add(EnsureElementPresentAsync(element, totalProgress?.CreateProgressNode(), cancellationToken));
}
// Lower level errors should be handled by EnsurePresent.
// If EnsurePresent fails we should bubble up because we can't be sure we can prepare the encounter.
await Task.WhenAll(presentTasks).ConfigureAwait(false);
var playbackElements = new List <PlaybackEnvironmentElement> (elements.Count);
for (int i = 0; i < elements.Count; i++)
{
(var state, var element) = elements[i];
playbackElements.Add(new PlaybackEnvironmentElement(state, element)); //, presentTasks[i].Result));
}
return(new PlaybackEnvironment(playbackElements));
}
public void Add(EnvironmentElement element)
{
BaseAdd(element);
}
//but make preview in Project window override public Texture2D RenderStaticPreview(string assetPath, UnityEngine.Object[] subAssets, int width, int height) => EnvironmentElement.GetLatLongThumbnailTexture(target as Environment, width);
public static FhirToolArguments Create(string[] args)
{
EnsureArg.IsNotNull(args, nameof(args));
FhirToolArguments arguments = new FhirToolArguments();
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
switch (arg)
{
case GENERATE_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.Generate;
break;
case UPLOAD_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.Upload;
break;
case UPLOAD_DEFINITIONS_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.UploadDefinitions;
break;
case BUNDLE_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.Bundle;
break;
case SPLIT_BUNDLE_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.SplitBundle;
break;
case TRANSFER_DATA_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.TransferData;
break;
case VERIFY_VALIDATION_OP:
if (arguments.Operation != OperationEnum.None)
{
throw new MultipleOperationException(arguments.Operation);
}
arguments.Operation = OperationEnum.VerifyValidation;
break;
case QUESTIONNAIRE_ARG:
case QUESTIONNAIRE_SHORT_ARG:
arguments.QuestionnairePath = args[i + 1];
break;
case VALUESET_ARG:
case VALUESET_SHORT_ARG:
arguments.ValueSetPath = args[i + 1];
break;
case FHIRBASEURL_ARG:
case FHIRBASEURL_SHORT_ARG:
arguments.FhirBaseUrl = args[i + 1];
break;
case VERSION_ARG:
case VERSION_SHORT_ARG:
arguments.Version = args[i + 1];
break;
case RESOLVEURL_ARG:
case RESOLVEURL_SHORT_ARG:
arguments.ResolveUrl = true;
break;
case VERBOSE_ARG:
case VERBOSE_SHORT_ARG:
arguments.Verbose = true;
break;
case MIMETYPE_ARG:
case MIMETYPE_SHORT_ARG:
string mimeType = args[i + 1].ToLowerInvariant();
if (!SUPPORTED_MIMETYPES.Contains(mimeType))
{
throw new NotSupportedMimeTypeException(mimeType);
}
arguments.MimeType = mimeType;
break;
case SOURCE_ARG:
case SOURCE_SHORT_ARG:
arguments.SourcePath = args[i + 1];
break;
case OUT_ARG:
case OUT_SHORT_ARG:
arguments.OutPath = args[i + 1];
break;
case CREDENTIALS_ARG:
case CREDENTIALS_SHORT_ARG:
arguments.Credentials = args[i + 1];
break;
case ENVIRONMENT_ARG:
case ENVIRONMENT_SHORT_ARG:
arguments.Environment = args[i + 1];
EnvironmentSection environmentSection = (EnvironmentSection)ConfigurationManager.GetSection($"environmentSection");
EnvironmentElement environment = (EnvironmentElement)environmentSection.Items[arguments.Environment];
arguments.FhirBaseUrl = environment.FhirBaseUrl;
arguments.ProxyBaseUrl = environment.ProxyBaseUrl;
break;
case ENVIRONMENT_SOURCE_ARG:
case ENVIRONMENT_SOURCE_SHORT_ARG:
arguments.SourceEnvironment = args[i + 1];
break;
case ENVIRONMENT_DESTINATION_ARG:
case ENVIRONMENT_DESTINATION_SHORT_ARG:
arguments.DestinationEnvironment = args[i + 1];
break;
case RESOURCETYPE_ARG:
case RESOURCETYPE_SHORT_ARG:
arguments.ResourceType = EnumUtility.ParseLiteral <ResourceType>(args[i + 1]);
break;
case SEARCHCOUNT_ARG:
case SEARCHCOUNT_SHORT_ARG:
int searchCount;
if (!int.TryParse(args[i + 1], out searchCount))
{
throw new RequiredArgumentException($"{SEARCHCOUNT_ARG}|{SEARCHCOUNT_SHORT_ARG}");
}
arguments.SearchCount = searchCount;
break;
case SKIP_VALIDATION_ARG:
case SKIP_VALIDATION_SHORT_ARG:
arguments.SkipValidation = true;
break;
default:
break;
}
}
return(arguments);
}
public sealed override VisualElement CreateInspectorGUI() => m_EnvironmentElement = new EnvironmentElement(target as Environment);
void OnTriggerEnter(Collider collider)
{
activeEnvElement.Unspawn();
activeEnvElement = ChooseNewEnvElement();
activeEnvElement.Spawn();
}
/// <summary>
/// Initializes a new instance of the <see cref="EnvironmentElementPropertyDescriptor"/> class.
/// </summary>
/// <param name="environments">The environments.</param>
/// <param name="environment">The environment.</param>
public EnvironmentElementPropertyDescriptor(EnvironmentElementCollection environments, EnvironmentElement environment)
: base(environment.Name, null)
{
this.environments = environments;
this.environment = environment;
}
