private void informAllObserver(TargetState state)
{
foreach (GameObject observer in observerEnemies)
{
observer.GetComponent <Enemy>().inform(state);
}
}
/// <summary>
/// Uploads the replay file to a S3 bucket and notifies the HotsLogs website.
/// </summary>
/// <param name="fileInfo"></param>
public void Notify(FileInfo fileInfo)
{
var request = new PutObjectRequest()
{
BucketName = "heroesreplays",
Key = Guid.NewGuid().ToString("D") + ".StormReplay",
FilePath = fileInfo.FullName,
};
var response = client.PutObject(request);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
NotifyHotsLogs(request.Key)
.ContinueWith(success =>
{
if (success.Result)
{
TargetState.Update(Name, fileInfo.CreationTimeUtc);
}
});
}
else
{
ReplayPublisher.Log.Warning("File {filePath} was no succesfully uploaded to the HotsLogs S3 bucket.\nReturned statuscode: {statusCode}", fileInfo.FullName, response.HttpStatusCode);
}
}
static void Damage(ref int health, double dist, TargetState state, bool precision)
{
/*
* Max bullet damage=20
*
* Target's immunity to bullet damage:
* Aggressive: >30m damage=0
* Moderate: >300m damage=0
* Calm: @500m damage=9
*/
int damage = 0;
if (state == TargetState.Moderate)
{
damage = (int)(20 * (Math.Exp(-dist / 100)));
}
else if (state == TargetState.Aggressive)
{
damage = (int)(20 * (Math.Exp(-dist / 10)));
}
else if (state == TargetState.Calm)
{
damage = (int)(20 * (Math.Exp(-dist / 700)));
}
// precision damage bonus (+50%)
if (precision)
{
damage = (int)(damage * 1.5);
Console.WriteLine("[Precision bonus (+50%)] ");
}
health -= damage;
Console.WriteLine("Damage: {0}, Health Remaining: {1}", damage, health);
}
// event handlers
private void HandlePlayerDeathEvent(ZMPlayerInfoEventArgs args)
{
if (_playerInfo == args.info)
{
_targetState = TargetState.DEAD;
}
}
public StateUpdateEventArgs(TargetState state)
{
mState = state;
mThread = null;
mFile = "";
mLine = 0;
}
public StateUpdateEventArgs(TargetState state, LuaValue thread, String file, int line)
{
mState = state;
mThread = thread;
mFile = file;
mLine = line;
}
void RemoveTargeting()
{
currentlyTargeting = false;
movementScript.ToggleTargeting(currentlyTargeting, nearestTarget);
stateOfTargeting = TargetState.NoTarget;
ToggleTargetVisual();
}
private void Awake()
{
canvas = CanvasObject.GetComponent <Canvas>();
BulletsRed = BulletsRedObject.GetComponentsInChildren <Image>();
BulletsBlue = BulletsBlueObject.GetComponentsInChildren <Image>();
Targets = new TargetState[2];
Targets[RED] = new TargetState();
Targets[BLUE] = new TargetState();
Targets[RED].TargetObject = TargetRedObject;
Targets[BLUE].TargetObject = TargetBlueObject;
Targets[RED].HitObject = HitRedObject;
Targets[BLUE].HitObject = HitBlueObject;
Targets[RED].image = TargetRedObject.GetComponent <Image>();
Targets[BLUE].image = TargetBlueObject.GetComponent <Image>();
Targets[RED].hit = HitRedObject.GetComponent <Image>();
Targets[BLUE].hit = HitBlueObject.GetComponent <Image>();
Targets[RED].shootable = false;
Targets[BLUE].shootable = false;
CatLives = GetComponent <GrandmaCatLives>();
DontDestroyOnLoad(sceneSwitcher);
}
// Use this for initialization
void Start()
{
state = TargetState.Inactive;
rend = GetComponent <Renderer>();
targetController = GetComponent <TargetController>();
goalie = GameObject.FindGameObjectWithTag("Player").GetComponent <GoalieController>();
}
public void OnTargetStateChanged(TargetState e)
{
if (TargetStateChanged != null)
{
Invoke(() => TargetStateChanged(this, new TargetStateArgs(e)));
}
}
public void SetTarget(GameObject nTarget, Vector3 nTargetPoint, string nTargetType)
{
target = nTarget;
targetPoint = nTargetPoint;
tState = TargetState.Undecided;
//lastTargetPoint = nTargetPoint;
switch (nTargetType)
{
case "Unit":
targetType = Target.Unit;
break;
case "Resource":
targetType = Target.Resource;
break;
case "Location":
targetType = Target.Location;
break;
case "Building":
targetType = Target.Build;
break;
case "DropOff":
targetType = Target.DropOff;
break;
}
movement.target = nTargetPoint;
movement.RequestPath(targetPoint);
}
public void Notify(FileInfo fileInfo)
{
var content = new StreamContent(new StreamReader(fileInfo.FullName).BaseStream);
try
{
var response = client.PostAsync("http://upload.stormlogs.com/upload.php", content).Result;
var message = response.Content.ReadAsStringAsync().Result;
ReplayPublisher.Log.Information("Target: {0}\nFile: {1}\nResponse: {2}\nResponse content: {3}",
this.Name,
fileInfo.FullName,
response.StatusCode,
message);
if (response.StatusCode == HttpStatusCode.OK)
{
TargetState.Update(Name, fileInfo.CreationTimeUtc);
}
}
finally
{
content.Dispose();
}
}
/// <summary>
/// calculate target and update the boid info;
/// </summary>
/// <param name="sight"></param>
/// <param name="targetState"></param>
/// <param name="pos"></param>
/// <returns></returns>
Vector3?calc_update_boid(ref BaseUnitSight.Component sight, TargetState targetState, Vector3 pos)
{
Vector3?tgt = null;
var boidVector = sight.BoidVector;
if (boidVector.Potential > 0.0f)
{
var center = boidVector.Center.ToWorkerPosition(this.Origin);
if ((center - pos).sqrMagnitude > boidVector.SqrtBoidRadius())
{
tgt = center;
}
else if (targetState == TargetState.OutOfRange)
{
tgt = pos + boidVector.GetVector3(sight.TargetRange);
}
}
var current = Time.ElapsedTime;
var diffTime = (float)(current - sight.BoidUpdateTime);
boidVector.Potential = AttackLogicDictionary.ReduceBoidPotential(boidVector.Potential, diffTime);
sight.BoidUpdateTime = current;
sight.BoidVector = boidVector;
return(tgt);
}
Vector3 CheckNavPathAndTarget(Vector3 target, Vector3 current, float size, TargetState state, long uid, ref NavPathData path)
{
if (pointsDic.ContainsKey(uid) == false)
{
pointsDic[uid] = new Vector3[256];
}
var points = pointsDic[uid];
if (path.IsSetData == false || (target - path.target).sqrMagnitude > checkRange * checkRange)
{
NavMeshUtils.GetNavPoint(current, target, size, WalkableNavArea, out var count, points);
if (count > 0)
{
path.count = count;
path.current = 0;
path.target = target;
return(path.GetCurrentCorner(points));
}
}
else
{
if ((path.GetCurrentCorner(points) - current).sqrMagnitude < size * size)
{
path.Next();
}
return(path.GetCurrentCorner(points));
}
return(target);
}
private void OnCharacterClicked(Character character)
{
currentState = TargetState.CharacterSelected;
selectedCharacter = character;
character.ShowPossibleMoves();
GameManager.GetInstance().Triangulate();
}
public List <TargetItem> GetTargetsByState(TargetState state)
{
lock (this.locker)
{
var strState = state.ToString();
return(this.db.Table <TargetItem>().Where(t => t.State == strState).ToList());
}
}
public void SetTargetState(TargetState state)
{
if (state != m_targetState)
{
m_targetState = state;
Refresh();
}
}
private void HandlePlayerRespawnEvent(ZMPlayerControllerEventArgs args)
{
if (args.controller.gameObject.Equals(gameObject))
{
_targetState = TargetState.ALIVE;
_pointState = PointState.NEUTRAL;
}
}
public void Reset()
{
if (curTarget != null)
{
Destroy(curTarget);
}
m_state = TargetState.notBeHitted;
}
/// <summary>
/// Reset the move target of an agent
/// </summary>
public void ResetMoveTarget()
{
//initialize request
this.TargetRef = 0;
this.targetPos = new Vector3(0.0f, 0.0f, 0.0f);
this.TargetPathqRef = PathQueue.Invalid;
this.TargetReplan = false;
this.targetState = TargetState.None;
}
/// <summary>
/// Request a new move velocity
/// </summary>
/// <param name="vel">The agent's velocity</param>
public void RequestMoveVelocity(Vector3 vel)
{
//initialize request
this.TargetRef = 0;
this.targetPos = vel;
this.TargetPathqRef = PathQueue.Invalid;
this.TargetReplan = false;
this.targetState = TargetState.Velocity;
}
void ProcessMessage_StateUpdate()
{
TargetState state = (TargetState)m_readBuffer.ReadInt32();
Int64 thread = m_readBuffer.ReadObjectID();
int line = m_readBuffer.ReadInt32();
string filename = m_readBuffer.ReadString();
OnStateUpdate(state, new LuaValue(thread, LuaValueType.THREAD), mDebugManager.FindSourceFile(filename), line);
}
public TargetState GetState()
{
if (rootDecision.MakeDecision() is TargetState)
{
TargetState resultNode = (TargetState)rootDecision.MakeDecision();
return(resultNode);
}
return(null);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = SourceState?.GetHashCode() ?? 0;
hashCode = (hashCode * 397) ^ (Event?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (TargetState?.GetHashCode() ?? 0);
return(hashCode);
}
}
/// <summary>
/// 初始化Champion
/// </summary>
/// <param name="_champion"></param>
public void Init(Champion _champion)
{
champion = _champion;
map = GameObject.Find("Scripts").GetComponent <Map>();
gamePlayController = GameObject.Find("Scripts").GetComponent <GamePlayController>();
targetState = GetComponent <TargetState>();
//set stats
targetState.prefab = _champion.prefab;
}
//Set taget object and state, then scales the feedback to the target
public void Setup(ObjectBase target, TargetState state)
{
targetState = state;
this.target = target;
feedback.sortingOrder = 4;
StopCoroutine("Rescale");
StartCoroutine(Rescale(feedback.transform, target.GetFeedbackSize(), 0.2f));
}
private void OnTileClicked(HexCell tile)
{
if (tile.State == HexCell.TileState.ShowingRange)
{
tile.character = selectedCharacter;
selectedCharacter.MoveToTile(tile);
selectedCharacter = null;
currentState = TargetState.Normal;
}
}
public void Continue(ContinueStatus status)
{
if (State != TargetState.Paused)
throw new InvalidOperationException("Continue requires a Paused target");
if (!Kernel32.ContinueDebugEvent(lastEvent.ProcessId, lastEvent.ThreadId, status))
throw new InvalidOperationException("ContinueDebugEvent failed");
State = (lastEvent.EventCode == DebugEventCode.RipEvent | lastEvent.EventCode == DebugEventCode.ExitProcess)
? TargetState.Exited /* todo: handle this properly */
: TargetState.Running;
}
public void OnMouseExit()
{
if (state == TargetState.Held)
{
goalie.Save(0);
state = TargetState.Inactive;
}
if (state == TargetState.Inactive)
{
rend.enabled = false;
}
}
public void ChangeState(TargetState state)
{
if(state != m_state)
{
m_state = state;
m_stateChanged = true;
if(StateChanged != null)
{
StateChanged(this, null);
}
}
}
void FixedUpdate()
{
switch (state)
{
case TargetState.THINK:
m_Rigidbody.MovePosition(Snap(m_Transform.position));
thinkRemaining -= Time.deltaTime;
if (thinkRemaining <= 0.0f)
{
if (IsNearDoor())
{
state = TargetState.DOOR;
}
else
{
thinkRemaining = thinkTime;
state = TargetState.EXPLORE;
currentDirection = PickDirection();
}
}
break;
case TargetState.EXPLORE:
if (IsNearDoor())
{
m_Transform.position = Snap(m_Transform.position);
state = TargetState.THINK;
}
else if (IsDirectionBlocked(currentDirection))
{
m_Transform.position = Snap(m_Transform.position);
state = TargetState.THINK;
}
else
{
m_Rigidbody.velocity = currentDirection * speed;
}
break;
case TargetState.DOOR:
{
door.targetEntered = true;
currentDirection = door.transform.position - m_Transform.position;
currentDirection.Normalize();
m_Rigidbody.velocity = currentDirection * doorEntrySpeed;
}
break;
case TargetState.DEAD:
break;
}
}
public void Report(int signature, Vector3 position)
{
if (!TargetReports.ContainsKey(signature))
{
visualise.AddShortData("Action", "New Target Recieved");
TargetReports.Add(signature, new TargetState(signature, position));
}
else if (TargetReports.ContainsKey(signature))
{
TargetState ts = TargetReports[signature];
ts.position = position;
}
}
public void SwitchToState(TargetState s)
{
this.state = s;
switch (this.state)
{
case TargetState.UNHIT:
this.SwitchToUnhit();
break;
case TargetState.HIT:
this.SwitchToHit();
break;
}
}
void Update()
{
if (state == TargetState.Hungry) {
m_currentHunger += Time.deltaTime * hungerIncreaseRate;
m_currentHunger = Mathf.Clamp(m_currentHunger, 0f, maxHunger);
if (Mathf.Abs(m_currentHunger) < float.Epsilon) {
state = TargetState.Full;
}
}
else if (state == TargetState.Full) {
currentFullDuration -= Time.deltaTime;
if (currentFullDuration < 0f) {
state = TargetState.Hungry;
}
}
}
internal void SetTargetState (int tid, TargetState state)
{
builds[tid] = state;
}
public void Detach()
{
if (pi == null)
throw new InvalidOperationException("There is no process to detach from");
Kernel32.DebugSetProcessKillOnExit(false);
Kernel32.DebugActiveProcessStop(pi.dwProcessId);
State = TargetState.Detached;
pi = null;
Program.OutputMessage("Detached.");
}
private void OnStateUpdate(TargetState targetState, LuaValue thread, String file, int line)
{
StateUpdateEventArgs args = new StateUpdateEventArgs(targetState, thread, file, line);
if (mLastUpdateMessage == null || !mLastUpdateMessage.Equals(args))
{
mLastUpdateMessage = args;
if (mForm != null && mForm.IsHandleCreated)
mForm.BeginInvoke(new MethodInvoker(delegate()
{
if (this.StateUpdate != null)
this.StateUpdate(this, args);
}));
}
}
public virtual void deselect()
{
m_targetState = TargetState.Normal;
}
public GetDs3TargetsSpectraS3Request WithState(TargetState? state)
{
this._state = state;
if (state != null)
{
this.QueryParams.Add("state", state.ToString());
}
else
{
this.QueryParams.Remove("state");
}
return this;
}
void DispatchEvent(DebugEvent e)
{
Program.OutputMessage("DispatchEvent code={0} pid=0x{1:X8} tid=0x{2:X8}", e.EventCode, e.ProcessId, e.ThreadId);
State = TargetState.Paused;
/* todo: do something with some of these events! */
if (e.EventCode == DebugEventCode.LoadDll)
{
var sb = new StringBuilder(1024);
Psapi.GetMappedFileName(pi.hProcess, e.LoadDll.lpBaseOfDll, sb, sb.Capacity);
Program.OutputMessage("LoadDll: {0} @ 0x{1:X8}", sb.ToString(), (uint)(ulong)e.LoadDll.lpBaseOfDll.ToInt64());
}
}
// Use this for initialization
void Start()
{
this._levelController = GameObject.FindObjectOfType<LevelController>();
this._fader = this.GetComponent<Fader>();
this._collider = this.GetComponent<Collider2D>();
this._renderer = this.GetComponent<Renderer>();
this.state = TargetState.UNHIT;
this._rotater = GetComponent<Rotater>();
if (!this._rotater) this._rotater = this.gameObject.AddComponent<Rotater>(); //testing
this._originalRotation = this.transform.rotation;
_missiles = this.GetComponentsInChildren<Missile>();
_flash = Camera.main.GetComponent<ColorFlash>();
}
private static void CompileProject(TargetState toState, string sourcePath)
{
var directory = Path.GetDirectoryName(sourcePath);
Console.WriteLine(directory);
XmlDocument PrXmlDoc = new XmlDocument();
PrXmlDoc.Load(sourcePath);
if (File.Exists(directory + @"\ImplemetationPlan.ip"))
{
Console.WriteLine("RemoveIP");
File.Delete(directory + @"\ImplemetationPlan.ip");
}
if (File.Exists(directory + @"\Qdeterminant.qd"))
{
Console.WriteLine("Remover QD");
File.Delete(directory + @"\Qdeterminant.qd");
}
XmlNode newListFile = PrXmlDoc.CreateNode(XmlNodeType.Element, "Files", null);
if (File.Exists(directory + @"\FlowChart.fc"))
{
Console.WriteLine("Compile fc in project");
XmlNode fNode = PrXmlDoc.CreateNode(XmlNodeType.Element, "File", null);
XmlAttribute path = PrXmlDoc.CreateAttribute("Path");
path.InnerText = "FlowChart.fc";
fNode.Attributes.Append(path);
XmlAttribute type = PrXmlDoc.CreateAttribute("Type");
type.InnerText = "FlowChart";
fNode.Attributes.Append(type);
newListFile.AppendChild(fNode);
if (toState == TargetState.QDeterminant)
{
XmlNode qNode = PrXmlDoc.CreateNode(XmlNodeType.Element, "File", null);
XmlAttribute qpath = PrXmlDoc.CreateAttribute("Path");
qpath.InnerText = "Qdeterminant.qd";
qNode.Attributes.Append(qpath);
XmlAttribute qtype = PrXmlDoc.CreateAttribute("Type");
qtype.InnerText = "Qdeterminant";
qNode.Attributes.Append(qtype);
newListFile.AppendChild(qNode);
CompileFcToQd(directory + @"\FlowChart.fc");
}
else
{
if (toState == TargetState.ImplementationPlan)
{
XmlNode qNode = PrXmlDoc.CreateNode(XmlNodeType.Element, "File", null);
XmlAttribute qpath = PrXmlDoc.CreateAttribute("Path");
qpath.InnerText = "Qdeterminant.qd";
qNode.Attributes.Append(qpath);
XmlAttribute qtype = PrXmlDoc.CreateAttribute("Type");
qtype.InnerText = "Qdeterminant";
qNode.Attributes.Append(qtype);
newListFile.AppendChild(qNode);
XmlNode iNode = PrXmlDoc.CreateNode(XmlNodeType.Element, "File", null);
XmlAttribute ipath = PrXmlDoc.CreateAttribute("Path");
ipath.InnerText = "ImplementationPlan.ip";
iNode.Attributes.Append(ipath);
XmlAttribute itype = PrXmlDoc.CreateAttribute("Type");
itype.InnerText = "ImplementationPlan";
iNode.Attributes.Append(itype);
newListFile.AppendChild(iNode);
CompileFcToIp(directory + @"\FlowChart.fc");
}
}
}
XmlNode rChild = PrXmlDoc.SelectSingleNode("//Files");
PrXmlDoc.SelectSingleNode("//Project").RemoveChild(rChild);
PrXmlDoc.SelectSingleNode("//Project").AppendChild(newListFile);
PrXmlDoc.Save(sourcePath);
}
private void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
int state = 0;
if (stream.isWriting)
{
if(m_stateChanged)
{
m_stateChanged = false;
state = (int)m_state;
stream.Serialize(ref state);
}
}
else
{
stream.Serialize(ref state);
TargetState newState = (TargetState)state;
if(newState != m_state)
{
m_state = newState;
if(StateChanged != null)
{
StateChanged(this, null);
}
}
}
}
protected TargetState change_target_state(TargetState new_state)
{
return change_target_state (new_state, 0);
}
TargetState change_target_state(TargetState new_state, int arg)
{
if (new_state == target_state)
return target_state;
TargetState old_state = target_state;
target_state = new_state;
if (StateChanged != null)
StateChanged (target_state, arg);
return old_state;
}
public virtual void select()
{
m_targetState = TargetState.Targeted;
}
static void CompileSolution(TargetState toState, string sourcePath)
{
Console.WriteLine("Compile Solution");
var directory_path = Path.GetDirectoryName(sourcePath);
var doc = new XmlDocument();
doc.Load(sourcePath);
var Oconverter = Manufactory.CreateOperationConverter(ConverterTypes.JSON);
Oconverter.ParseDocument(Path.Combine(Path.GetDirectoryName(sourcePath),doc.SelectSingleNode("//Operations").Attributes["Path"].InnerText));
if (countNode == null)
{
countNode = ulong.Parse(doc.SelectSingleNode("//maxCPU").InnerText);
}
Opertaions = Oconverter.GetBlocks();
foreach (XmlNode project in doc.SelectNodes("//Project"))
{
Console.WriteLine("Compile Project");
CompileProject(toState,Path.Combine(directory_path,project.Attributes["Path"].InnerText));
}
}
public void StopAudio()
{
TargetAudioFile = "";
if (waveOutDevice != null)
{
waveOutDevice.Stop();
}
if (audioFileReader != null)
{
audioFileReader.Dispose();
audioFileReader = null;
}
if (vorbisFileReader != null)
{
vorbisFileReader.Dispose();
vorbisFileReader = null;
}
if (waveOutDevice != null)
{
waveOutDevice.Dispose();
waveOutDevice = null;
}
this.targetState = TargetState.NOTHING;
}
public void PlayRandomTrack()
{
Random random = new Random();
this.TargetAudioFile = this.Playlist[random.Next(this.Playlist.Count)];
this.waveOutDevice = new WaveOut();
if (this.TargetAudioFile.EndsWith(".mp3") || this.TargetAudioFile.EndsWith(".wav"))
{
this.audioFileReader = new AudioFileReader(this.TargetAudioFile);
this.waveOutDevice.Init(audioFileReader);
}
else if (this.TargetAudioFile.EndsWith(".ogg"))
{
this.vorbisFileReader = new VorbisFileReader(this.TargetAudioFile);
this.waveOutDevice.Init(vorbisFileReader);
}
this.waveOutDevice.Volume = 1.0f; // Unfortunately, VorbisFileReader does not have volume control
this.waveOutDevice.Play();
this.targetState = TargetState.NOTHING;
}
public TargetStatusProperty(TargetState value)
{
this.value = value;
}
//Change the state to received state
public void ChangeState(TargetState state)
{
targetState = state;
}
void FixedUpdate()
{
if(target == null){
targetType = Target.None;
}
if(targetType == Target.None && anim.state != "Idle"){
anim.state = "Idle";
anim.Animate();
}
else if(targetType == Target.Resource){
if(resource.source == null){
resource.source = target.GetComponent<ResourceSource>();
resource.target = target;
}
else if(resource.source.gameObject != target){
resource.source = target.GetComponent<ResourceSource>();
resource.target = target;
}
if(movement.pathComplete){
transform.LookAt(new Vector3(target.transform.position.x, transform.position.y, target.transform.position.z));
if(anim.state != "Gather"){
anim.state = "Gather";
anim.Animate();
}
if(resource.Gather(this, gameObject)){
}
else{
ResetTarget();
}
}
else if(anim.state != "Move"){
anim.state = "Move";
anim.Animate();
}
}
else if(targetType == Target.Unit){
if(movement.pathComplete){
transform.LookAt(new Vector3(target.transform.position.x, transform.position.y, target.transform.position.z));
if(!weapon.InRange(target.transform.position, transform.position)){
if(anim.state != "Move"){
anim.state = "Move";
anim.Animate();
}
movement.target = target.transform.position;
movement.GetPath(target.transform.position);
lastTargetPoint = target.transform.position;
}
else{
}
if(tState == TargetState.Undecided){
UnitController targetController = target.GetComponent<UnitController>();
if(mGroup.relations[targetController.group].state == 0){
tState = TargetState.Ally;
}
else if(mGroup.relations[targetController.group].state == 1){
tState = TargetState.Neutral;
}
else if(mGroup.relations[targetController.group].state == 2){
tState = TargetState.Enemy;
}
else if(mGroup.relations[targetController.group].state == 3){
tState = TargetState.Self;
}
}
else if(tState == TargetState.Ally){
}
else if(tState == TargetState.Neutral){
// I haven't quite figured out what to do here so I recommend against setting anything to neutral at this moment
}
else if(tState == TargetState.Enemy){
weapon.AttackObject(target, gameObject, "Unit", type);
if(weapon.fighterUnit && anim.state != "Attack"){
anim.state = "Attack";
anim.Animate();
}
}
}
else if(anim.state != "Move"){
anim.state = "Move";
anim.Animate();
}
if(weapon.InRange(target.transform.position, transform.position)){
movement.pathComplete = true;
}
}
else if(targetType == Target.Location){
if(movement.pathComplete){
ResetTarget();
}
else if(anim.state != "Move"){
anim.state = "Move";
anim.Animate();
}
}
else if(targetType == Target.Build){
float dist = (transform.position - target.transform.position).sqrMagnitude;
if(dist < build.buildDist){
movement.pathComplete = true;
}
if(movement.pathComplete){
transform.LookAt(new Vector3(target.transform.position.x, transform.position.y, target.transform.position.z));
if(tState == TargetState.Undecided){
BuildingController targetController = target.GetComponent<BuildingController>();
if(mGroup.relations[targetController.group].state == 0){
tState = TargetState.Ally;
}
else if(mGroup.relations[targetController.group].state == 1){
tState = TargetState.Neutral;
}
else if(mGroup.relations[targetController.group].state == 2){
tState = TargetState.Enemy;
}
else if(mGroup.relations[targetController.group].state == 3){
tState = TargetState.Self;
}
}
if(tState == TargetState.Self){
if(build.source == null){
build.source = target.GetComponent<BuildingController>();
}
else if(build.source.gameObject != target){
build.source = target.GetComponent<BuildingController>();
}
else{
if(build.Build()){
if(anim.state != "Build"){
anim.state = "Build";
anim.Animate();
}
}
else{
ResetTarget();
}
}
}
else if(tState == TargetState.Enemy){
weapon.AttackObject(target, gameObject, "Building", type);
if(anim.state != "Attack"){
anim.state = "Attack";
anim.Animate();
}
}
}
else if(anim.state != "Move"){
anim.state = "Move";
anim.Animate();
}
}
else if(targetType == Target.DropOff){
float dist = (transform.position - target.transform.position).sqrMagnitude;
if(dist < build.buildDist){
movement.pathComplete = true;
}
if(movement.pathComplete){
transform.LookAt(new Vector3(target.transform.position.x, transform.position.y, target.transform.position.z));
resource.DropOff(this);
}
else if(anim.state != "Move"){
anim.state = "Move";
anim.Animate();
}
}
}
public MusicPlayer()
{
this.TargetAudioFile = "";
this.targetState = TargetState.NOTHING;
}
//Set taget object and state, then scales the feedback to the target
public void Setup(ObjectBase target, TargetState state)
{
targetState = state;
this.target = target;
feedback.sortingOrder = 4;
StopCoroutine("Rescale");
StartCoroutine(Rescale(feedback.transform, target.GetFeedbackSize(), 0.2f));
}
// Only works if Update() is being called in the main loop
public void FadeStop()
{
if (this.IsPlaying)
{
this.targetState = TargetState.FADEOUT;
}
}
