void Start()
{
_mainCamera = Camera.main;
_targetController = FindObjectOfType <TargetController>();
_playerController = FindObjectOfType <PlayerController>();
_behaviorScript = GetComponent <IEnemyBehavior>();
}
public void Evaluate(IBlackBox box)
{
// Random starting point in radius 20
Vector3 dir = new Vector3(UnityEngine.Random.Range(-1f, 1f), 0, UnityEngine.Random.Range(-1f, 1f));
Vector3 pos = dir.normalized * 20;
pos.y = 1;
GameObject obj = Instantiate(Robot, pos, Quaternion.identity) as GameObject;
TrainingController robo = obj.GetComponent <TrainingController>();
Target.transform.position = new Vector3(0, 1, 0);
Target.transform.localScale = new Vector3(Settings.Brain.TargetSize, 2, Settings.Brain.TargetSize);
dict.Add(box, robo);
if (Settings.Brain.MultipleTargets)
{
GameObject t = Instantiate(Target, new Vector3(0, 1, 0), Quaternion.identity) as GameObject;
t.transform.localScale = new Vector3(1, 1, 1);
TargetController tc = t.AddComponent <TargetController>();
tc.Activate(obj.transform);
targetDict.Add(robo, tc);
robo.Activate(box, t);
}
else
{
robo.Activate(box, Target);
}
evaluationStartTime = 0;
}
public override void Init()
{
base.Init();
if (matricies == null)
{
// Set Matrix Set
matricies = new EmitterMatricies();
matricies.Init();
}
if (targetController == null)
{
targetController = new TargetController();
}
if (emitterController == null)
{
emitterController = new EmitterController();
}
if (reflectorController == null)
{
reflectorController = new ReflectorController();
}
if (boxController == null)
{
boxController = new BoxController();
}
InitScenePuzzle();
}
/// <summary>
/// 敵をロックオンする
/// </summary>
public void LockOnEnemy(TargetController target)
{
Debug.Log("Lock on Enemy");
if (m_target == target)
{
return;
}
m_target = target;
if (m_target)
{
Vector3 lookAtTarget = target.transform.position;
lookAtTarget.y = m_player.transform.position.y;
m_player.transform.LookAt(lookAtTarget);
}
if (m_targetGroup)
{
m_targetGroup.AddMember(m_target.transform, m_weight, m_radius);
}
if (!IsLock)
{
if (m_targetCamera)
{
m_targetCamera.Follow = m_followTemp;
m_targetCamera.Priority = m_priority;
}
/*フリールックのfollowとlookAtを空にしないとtransformを操作できない*/
if (m_fcum)
{
m_fcum.Follow = null;
m_fcum.LookAt = null;
}
}
IsLock = true;
}
private void Awake()
{
controller = GameObject.FindGameObjectWithTag("Controller").GetComponent <ControllerController>();
targetController = controller.targetController;
headFixedJoint = transform.GetChild(1).gameObject.GetComponent <FixedJoint>();
headFixedJoint.breakForce = targetController.headJointBreakForce;
}
private IEnumerator Start()
{
// менеджер локализации
while (!LocalizationManager.instance.GetIsReady())
{
yield return(null);
}
// менеджер диалогов
while (!CompanyDialogManager.GetInstance().GetIsReady())
{
yield return(null);
}
// менеджер компании
while (!CompanyManager.GetInstance().GetIsReady())
{
yield return(null);
}
// менеджер дуэли
while (!DuelManager.GetInstance().GetIsReady())
{
yield return(null);
}
// менеджер целей
while (!TargetController.GetInstance().GetIsReady())
{
yield return(null);
}
// после загрузки всех компонент - включаем меню
SceneManager.LoadScene("MainMenu");
}
void Start()
{
CleanupTemp();
if (TargetController)
{
TargetController.CleanupTemp();
}
GetComponent <Renderer>().enabled = true;
if (!Application.isPlaying)
{
return;
}
//Todo: Once fully functioning and verified, remove this
/*
* GlobalPortalSettings settings = GlobalPortalSettings.Instance;
* if (!settings)
* {
* settings = Resources.Load<GlobalPortalSettings>("Global Portal Settings");
* settings.OnEnable();
* }*/
SKSGlobalRenderSettings.Instance.OnEnable();
//Load the Portal prefab
StartCoroutine(Setup());
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.tag == "Player Attack")
{
rb.isKinematic = false;
Vector3 dir = (transform.position - other.transform.position).normalized;
dir.y = 0.0f;
rb.AddForce(dir * 7.5f, ForceMode.Impulse);
}
if (other.gameObject.tag == "Bumper")
{
rb.isKinematic = false;
Vector3 dir = (transform.position - other.transform.position).normalized;
dir.y = 0.0f;
rb.AddForce(dir * 10.0f, ForceMode.Impulse);
audioSource.pitch = (Random.Range(0.9f, 1.1f));
audioSource.PlayOneShot(sfxBumper, 1f);
}
if (other.gameObject.tag == "Kill Zone")
{
rb.velocity = new Vector3(0f, -0.11f, 0);
transform.position = startPosition;
}
if (other.gameObject.tag == "Target")
{
TargetController tc = other.gameObject.GetComponent <TargetController>();
tc.Activate();
}
}
public override PlayerState HandleInput()
{
if (TargetController.HandleHandGrabInputs() == 0)
{
Jump(forceToAdd);
return(StateMachine.PlayerStates.IdleAir);
}
if (Input.GetKey(KeyCode.Q) && Input.GetKey(KeyCode.W))
{
if (BothHandsGrabbing())
{
if (BothHandsGrabbingSameObject())
{
return(StateMachine.PlayerStates.JumpReady);
}
else
{
return(StateMachine.PlayerStates.DoubleGrab);
}
}
else
{
rotatingHand.Attach(nonRotatingHand.GrabbedObject);
return(StateMachine.PlayerStates.JumpReady);
}
}
return(base.HandleInput());
}
private void OnDisable()
{
CleanupTemp();
if (!Application.isPlaying)
{
return;
}
//EditorApplication.update -= UpdatePreview;
if (TargetController && TargetController.TargetController)
{
TargetController.TargetController.CleanupTemp();
}
//DestroyImmediate(_matEditor, true);
if (Application.isPlaying)
{
return;
}
if (TargetController)
{
TargetController.GetComponent <Renderer>().enabled = true;
}
if (TargetController)
{
TargetController.GetComponent <Renderer>().sharedMaterial.color = TargetController.color;
}
}
protected virtual void OnInitialize()
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
opponentMem = new OpponentMemory(this);
targetCtrl = new TargetController(this);
moveCtrl = new MoveController(this);
weaponCtrl = new WeaponController(this);
opponentMemSpanTimer = new SpanTimer(param.thinkParam.opponentMemorySpan);
targetUpdateSpanTimer = new SpanTimer(param.thinkParam.targetUpdateSpan);
_frontTransform = GetFront();
_backTransform = GetBack();
rootInternalRedius = param.sensorParam.internalRadius * GetScale();
Vector2 val = frontPositionXZ - owner.positionXZ;
rootFrontDistance = val.get_magnitude() - rootInternalRedius;
Vector2 val2 = backPositionXZ - owner.positionXZ;
rootBackDistance = val2.get_magnitude() - rootInternalRedius;
}
// Use this for initialization
void Start()
{
state = TargetState.Inactive;
rend = GetComponent <Renderer>();
targetController = GetComponent <TargetController>();
goalie = GameObject.FindGameObjectWithTag("Player").GetComponent <GoalieController>();
}
void Start()
{
playerCamera = GetComponent <Camera> ();
weaponController = GetComponent <WeaponController> ();
targetController = target.GetComponent <TargetController> ();
score = 0;
}
private void Awake()
{
soccerBallTransform = soccerBall.GetComponent <Transform>();
soccerBallRigidbody = soccerBall.GetComponent <Rigidbody>();
targetController = target.GetComponent <TargetController>();
// Soccer Ball
soccerBall.SetActive(false);
soccerBallRigidbody.useGravity = false;
originalPosition = soccerBallTransform.position;
// UI
originalScoreTextColor = scoreText.color;
// States
gameMode = JuggleGameMode;
score = 0;
scoreTime = 0;
juggleHighScore = PlayerPrefs.GetInt("JuggleHighScore", 0);
juggleHighScoreText.text = $"HIGH SCORE: {juggleHighScore.ToString()}";
timeTrialHighScore = PlayerPrefs.GetFloat("TimeTrialHighScore", 0);
timeTrialHighScoreText.text = $"HIGH SCORE: {timeTrialHighScore.ToString("0.00")} SECONDS";
targetPracticeHighScore = PlayerPrefs.GetInt("TargetPracticeHighScore", 0);
targetPracticeHighScoreText.text = $"HIGH SCORE: {targetPracticeHighScore.ToString()}";
beatTheClockHighScore = PlayerPrefs.GetFloat("BeatTheClockHighScore", 0);
beatTheClockHighScoreText.text = $"HIGH SCORE: {beatTheClockHighScore.ToString("0.00")} SECONDS";
}
private void Awake()
{
if (!instance)
{
instance = this;
}
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
if (EventSystem.current.IsPointerOverGameObject())
{
return;
}
RaycastHit hit;
if (Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward), out hit, Mathf.Infinity, layerMask))
{
GameObject instance = Instantiate(impact, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal), hit.collider.transform);
instance.transform.position += instance.transform.forward * .001f;
if (hit.collider.CompareTag("Target"))
{
#region animation
TargetController tc = hit.collider.gameObject.transform.parent.GetComponent <TargetController>();
tc.BeTouched();
combo.Value++;
kills.Value += 1;
#endregion
}
else
{
SoundManager.PlaySound(failSound);
combo.Value = 0;
UiManager.UpdateUI();
}
}
}
}
/// <summary>
/// Создание системы частиц, задание количества ножей для контейнера с иконками
/// </summary>
void Awake()
{
_impactEffect = Instantiate(_impactEffect);
_particles = _impactEffect.GetComponent <ParticleSystem>();
_knifesRemainController.KnifesNumber = _knifesRemain;
_targetController = _target.GetComponent <TargetController>();
_mainCamera = Camera.main;
}
//This function is called in Bullet.cs OnCollisionEnter via SendMessageUpwards
public virtual void OnHit(string entityID)
{
//Only send this message if you're the one who shot the target!
if (entityID.Equals(ExampleManager.Instance.CurrentNetworkedEntity.id))
{
TargetController.onTargetDestroyed(entityID, modelRef);
}
}
private void Awake()
{
instance = this;
cam = Camera.main;
target = Instantiate(targetPrefab).GetComponent <TargetManager>();
target.gameObject.SetActive(false);
isTargeting = false;
}
private void Awake()
{
// -- Cria uma instância
if (!instance)
{
instance = this;
}
}
void SignalChangeDirection()
{
foreach (GameObject target in targetList)
{
TargetController target_controller = target.GetComponent <TargetController>();
target_controller.ChangeTargetDirection();
}
}
// Start is called before the first frame update
void Start()
{
_wanderTimer = _wanderCooldown;
_attackTimer = _attackCooldown;
_levelController = FindObjectOfType <LevelController>();
_targetController = FindObjectOfType <TargetController>();
SetInitialMovement();
}
void Awake()
{
if (Instance != null)
{
throw new Exception("Singleton instance already exists");
}
Instance = this;
TargetController = GetComponent<TargetController>();
}
public override PlayerState HandleInput()
{
if (TargetController.HandleHandGrabInputs() < 2 && TimeWindowForInput == null)
{
TimeWindowForInput = TargetController.StartCoroutine(WaitForInput(timeWindowPeriod));
}
return(this);
}
public override PlayerState Update()
{
if (TargetController.HandleHandGrabInputs() < 2)
{
return(StateMachine.PlayerStates.Rotating);
}
return(base.Update());
}
private void Start() {
CleanupTemp();
if (TargetController)
TargetController.CleanupTemp();
GetComponent<Renderer>().enabled = true;
if (!Application.isPlaying) return;
SKSGlobalRenderSettings.Instance.OnEnable();
StartCoroutine(Setup());
}
void Awake()
{
controller = GetComponent<TargetController>();
GetComponent<Selectable>().Targeting.AddListener(target =>
{
controller.Target = target;
return false;
});
}
// Use this for initialization
void Start ()
{
voltageSource = GameObject.FindGameObjectWithTag("VoltageSource").GetComponent<VoltageSourceObject>();
voltageTarget = GameObject.FindGameObjectWithTag("VoltageTarget").GetComponent<TargetController>();
currentTargetConnectors = voltageTarget.connectors;
power = currentTargetConnectors[0];
ground = currentTargetConnectors[1];
isTurnedOn = false;
}
void AddToTargetMap(Sequence.Wall wall, Passage.Step step, TargetController target)
{
int key = CalculateMonobeat(wall, step);
if (!TargetMap.ContainsKey(key))
{
TargetMap.Add(key, new List <TargetController>());
}
TargetMap[key].Add(target);
}
private void PlayerBoost()
{
// access player controller and tell it to use top boost card/update whatever it needs
TargetController.SetTargetToPlayer();
StateMachine.Player.BoostAction(1);
StateMachine.Player.PlayBoostCard();
PlayerBoosted.Invoke();
EnemyBoost();
}
public void SetKey(string uniqueKeyName, AxisCode joystickAxis, TargetController targetController = TargetController.All)
{
int i = GetUniqueIndex(uniqueKeyName);
inputs[i].Type = KeyType.ControllerAxis;
inputs[i].Axis = joystickAxis;
inputs[i].targetController = targetController;
hUtility.SaveBinings(inputs);
}
//Add Equals, GetHashCode...
public override object GetDeepCopy()
{
IController clone = new TargetController("clone - " + this.ID, //deep
this.ControllerType, //deep
this.targetActor); //reference
clone.SetControllerPlayStatus(this.PlayStatusType);
return(clone);
}
//******************
// Target Controls
//******************
void SpawnTarget()
{
GameObject target = (GameObject)Instantiate(target_prefab, targetSpawnPoint, Quaternion.identity);
TargetController target_controller = target.GetComponent <TargetController>();
target_controller.InitializeTarget(targetSpawnPoint, targetEndPoint, targetSpeed, scoreMultiplier);
targetList.Add(target);
numTargetsSpawned++;
targetSpawnDelayRemaining = targetSpawnDelay;
}
public void Reset()
{
this.start.GetComponent<Light>().intensity = 0;
this.start = null;
if (this.end != null)
{
this.end.GetComponent<Light>().intensity = 0;
this.end = null;
}
}
public void SetUp()
{
_actionDescriptor = Substitute.For<ActionDescriptor>();
_controller = new TargetController();
_viewContex = new ViewContext();
var userManager = Substitute.For<IUsersManagement>();
_accessHelper = Substitute.For<IUserAccessHelper>();
_viewContex.HttpContext = MockHttpContext.FakeHttpContext();
_viewContex.HttpContext.Request.RequestContext.RouteData = new System.Web.Routing.RouteData();
_viewContex.HttpContext.Request.RequestContext.RouteData.Values.Add("controller", "c");
_viewContex.HttpContext.Request.RequestContext.RouteData.Values.Add("action", "a");
_controller.SetFakeControllerContext(_viewContex.HttpContext);
_viewContex.HttpContext.User.Identity.Name.Returns("username");
_attribute = new DVSAuthorizeFilterAttribute();
_attribute.AccessHelper = _accessHelper;
}
private void SetFirstTarget(ConnectorController connectorController)
{
connectorController.start = closestTarget;
FirstTarget = closestTarget;
RemoveHover();
TurnOnLights(Color.green, FirstTarget);
closestTarget = null;
}
private void Analyze()
{
int iterations = 0;
componentsPath = new List<GameObject>();
List<TargetController> targetsWithLEDs = new List<TargetController>();
//currentTargetConnectors = power.end.connectors;
previousTarget = power.end;
if(!FirstTargetHasTwoConnectors())
{
audioController.playClip(EnumScript.CustomAudioClips.failHorn);
return;
}
if(previousTarget.instantiated != null)
{
componentsPath.Add(previousTarget.instantiated);
if (previousTarget.instantiated.GetComponent<LED>() != null)
{
targetsWithLEDs.Add(previousTarget);
}
}
if( previousTarget.connectors[1].end != previousTarget)
{
currentTarget = previousTarget.connectors[1].end;
}
else
{
currentTarget = previousTarget.connectors[1].start;
}
while (currentTarget != voltageTarget && iterations < 20)
{
foreach (var connector in currentTarget.connectors)
{
if (connector.start != previousTarget && connector.end != previousTarget)
{
if (currentTarget.instantiated != null)
{
componentsPath.Add(currentTarget.instantiated);
if (currentTarget.instantiated.GetComponent<LED>() != null)
{
targetsWithLEDs.Add(currentTarget);
}
}
if (connector.start == currentTarget)
{
previousTarget = currentTarget;
currentTarget = connector.end;
}
else
{
previousTarget = currentTarget;
currentTarget = connector.start;
}
}
}
iterations++;
}
if(iterations == 20)
{
audioController.playClip(EnumScript.CustomAudioClips.failHorn);
return;
}
float totalResistance = 0;
List<GameObject> LEDInCircuit = new List<GameObject>();
float totalCurrent = 0;
foreach(var comp in componentsPath)
{
if(comp.GetComponent<LED>() != null)
{
LEDInCircuit.Add(comp);
}
else
{
//it's probably dangerous to assume it's a resistor if it isn't an LED but that's all we got :)
Resistor currentResistor = comp.GetComponent<Resistor>();
totalResistance += currentResistor.GetResistanceInOhms();
}
Debug.Log(comp.name);
}
totalCurrent = totalResistance == 0 ? Mathf.Infinity : voltageSource.GetVoltage() / totalResistance;
Debug.Log(totalResistance);
Debug.Log(voltageSource.GetVoltage());
Debug.Log(totalCurrent);
if(totalCurrent > LEDInCircuit[0].GetComponent<LED>().LEDExplode)
{
//explode LED here
//LEDInCircuit[0].GetComponentInChildren<ParticleEmitter>().Simulate(-2);
//LEDInCircuit[0].GetComponentInChildren<ParticleEmitter>().Emit();
foreach(var target in targetsWithLEDs)
{
target.instantiated.GetComponent<Animator>().Play("ExplodeLED");
audioController.playClip(EnumScript.CustomAudioClips.explosion);
target.instantiated = null;
}
}
else if (totalCurrent > LEDInCircuit[0].GetComponent<LED>().threshold)
{
turnOnLEDs(LEDInCircuit, totalCurrent);
audioController.playClip(EnumScript.CustomAudioClips.dingDing);
}
iterations = 0;
}
void Awake()
{
agent = GetComponent<NavMeshAgent> ();
target = GameObject.FindObjectOfType<TargetController> ();
}
private void SetHover(TargetController closestTarget)
{
hovering = closestTarget;
TurnOnLights(Color.red, hovering);
}
private void RemoveHover()
{
if(hovering == null)
{
return;
}
TurnOffLights(hovering);
hovering = null;
}
private void TurnOnLights(Color color,TargetController target)
{
target.GetComponent<Light>().color = color;
target.GetComponent<Light>().intensity = 2;
}
private void TurnOffLights(TargetController target)
{
target.GetComponent<Light>().intensity = 0;
}
private bool AttemptingDiagonal(ConnectorController CC, TargetController closestTarget)
{
return ((CC.start.transform.position - closestTarget.transform.position).x != 0 && (CC.start.transform.position - closestTarget.transform.position).z != 0);
}
private bool CheckDuplicates(ConnectorController connectorController, TargetController closestTarget)
{
foreach(Connector conn in closestTarget.connectors)
{
if((conn.start == closestTarget && conn.end == connectorController.start) || (conn.end == closestTarget && conn.start == connectorController.start))
{
return true;
}
}
return false;
}
private void PlaceWire(ConnectorController connectorController, TargetController closestTarget)
{
connectorController.end = closestTarget;
Connector newConnector = connectorController.PlaceWire();
closestTarget.connectors.Add(newConnector);
newConnector.start.connectors.Add(newConnector);
closestTarget.connectorIndex++;
newConnector.start.connectorIndex++;
newConnector.start.GetComponent<Light>().intensity = 0;
newConnector.end.GetComponent<Light>().intensity = 0;
FirstTarget = null;
waiting = true;
}
private void FixedUpdate()
{
closestTarget = finder.ClosestTarget();
//if we aren't close to anything remove the hovering and return
if(closestTarget == null)
{
RemoveHover();
return;
}
//connector select mode
else if (FirstTarget !=null)
{
if(closestTarget == FirstTarget)
{
RemoveHover();
}
if(closestTarget != FirstTarget && closestTarget != hovering)
{
RemoveHover();
SetHover(closestTarget);
}
}
else
{
if(hovering == null)
{
SetHover(closestTarget);
}
else if(hovering != null && closestTarget != hovering)
{
RemoveHover();
SetHover(closestTarget);
}
}
GameObject selected = null;
if(GameObject.FindGameObjectWithTag("HandModel") != null && GameObject.FindGameObjectWithTag("HandModel").GetComponent<IsPinching>().Pinching(1))
{
selected = finder.selected;
if (selected != null)
{
ConnectorController connectorController = selected.GetComponent<ConnectorController>();
if (connectorController == null)
{
if (closestTarget.instantiated == null)
{
closestTarget.instantiated = closestTarget.PlaceObject(selected);
}
else if (selected.name != closestTarget.instantiated.name) //there is an object on the target, but you are trying to place something else
{
Destroy(closestTarget.instantiated);
closestTarget.instantiated = closestTarget.PlaceObject(selected);
}
}
else
{
if (!waiting)
{
if (connectorController.start == null)
{
SetFirstTarget(connectorController);
}
else if (connectorController.end == null && closestTarget != connectorController.start)
{
if(AttemptingDiagonal(connectorController, closestTarget))
{
return;
}
bool duplicate = CheckDuplicates(connectorController,closestTarget);
if (!duplicate)
{
PlaceWire(connectorController, closestTarget );
}
}
}
else
{
if(waitingTime <= 0)
{
waiting = false;
waitingTime = 1f;
}
else
{
waitingTime -= Time.deltaTime;
}
}
}
}
}
}
