public override bool Test(Sim actor, Jetpack target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
{
if (!Jetpack.IsAllowedToUseJetpack(actor))
{
return false;
}
if (actor.GetActiveJetpack() == null)
{
return false;
}
if (actor.GetActiveJetpack() != target)
{
return false;
}
/*
if (actor.SimDescription.IsPregnant)
{
greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString(actor.IsFemale, "Gameplay/Actors/Sim:PregnantFailure", new object[0x0]));
return false;
}
*/
return true;
}
// Update is called once per frame
void Update()
{
try
{
if (type == "WayBack")
{
TimeJump typeO = player
.GetComponent <TimeJump>();
percentLeft = typeO.fuel / typeO.maxFuel;
}
else if (type == "JetPack")
{
Jetpack typeO = GameObject.Find("JetpackP").GetComponent <Jetpack>();
percentLeft = typeO.fuel / typeO.maxFuel;
}
if (changed != percentLeft)
{
Invoke("hide", 2f);
}
changed = percentLeft;
bar.localScale = new Vector3(1f, percentLeft);
}
catch
{
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PUBLIC FUNCTIONS ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public override void OnInspectorGUI()
{
GUI.changed = false;
// Get a reference to the extended class
Jetpack _jetpack = target as Jetpack;
// Display expandable section for movement related variables
EditorGUILayout.LabelField("Movement Options", EditorStyles.boldLabel);
_jetpack.maximumVelocity = EditorGUILayout.FloatField("Maximum Velocity", _jetpack.maximumVelocity);
_jetpack.boostForce = EditorGUILayout.FloatField("Boost Force", _jetpack.boostForce);
// Display section for landing options
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Landing Options", EditorStyles.boldLabel);
_jetpack.topLandingCheck = (Transform)EditorGUILayout.ObjectField("Top Landing Range Check", _jetpack.topLandingCheck, typeof(Transform), true);
_jetpack.bottomLandingCheck = (Transform)EditorGUILayout.ObjectField("Bottom Landing Range Check", _jetpack.bottomLandingCheck, typeof(Transform), true);
// Display expandable section for energy related options.
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Energy Options", EditorStyles.boldLabel);
_jetpack.boostCost = EditorGUILayout.FloatField("Boost Cost", _jetpack.boostCost);
_jetpack.takeOffCost = EditorGUILayout.FloatField("Take Off Cost", _jetpack.takeOffCost);
_jetpack.flyingEnergyRegenRate = EditorGUILayout.IntField("Flying Regen Rate (frames before regen)", _jetpack.flyingEnergyRegenRate);
_jetpack.anchoredEnergyRegenRate = EditorGUILayout.IntField("Anchored Regen Rate (frames before regen)", _jetpack.anchoredEnergyRegenRate);
// If changed then you need to set dirty
if (GUI.changed)
{
EditorUtility.SetDirty(_jetpack);
}
}
void Awake()
{
m_Jetpack = FindObjectOfType <Jetpack>();
DebugUtility.HandleErrorIfNullFindObject <Jetpack, JetpackCounter>(m_Jetpack, this);
FillBarColorChange.Initialize(1f, 0f);
}
public GameObject enterMechTooltipToHide; // ignored if null for levels besides #1
void Awake()
{
slopeWalker = GetComponent <SlopeWalker>();
slopeWalker.enabled = false;
Assert.IsNotNull(audioEvent);
firstIcon = GameObject.Find("Main UI/Icon Turret").GetComponent <AbilityIcon>();
secondIcon = GameObject.Find("Main UI/Icon Thrusters").GetComponent <AbilityIcon>();
mechOnlyMask = LayerMask.GetMask("Mechs");
playerBody = GetComponent <Rigidbody2D>();
spriteRenderer = GetComponent <SpriteRenderer>();
mainCam = Camera.main;
camScript = mainCam.GetComponent <MainCamera>();
cursor = UIResourceManager.MouseCursor; // NOTE: ai bots use this class but do not use mouse cursor
_state = PlayerState.outOfMech; //default player state, switches between in and out of mech
jetpack = GetComponent <Jetpack>();
if (weaponEquipped) // sanity check: some bots don't have this?
{
weapon = weaponEquipped.GetComponent <PlayerMachineGun>();
weaponManager.GiveWeapon(weapon);
}
isAiPlayer = GetComponent <AI>() != null;
EnableWeapons(true);
Invoke("SetDefaultIcons", 0.1f);
}
public override bool Test(Sim a, Sim target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
{
if (!Jetpack.IsAllowedToUseJetpack(a))
{
return(false);
}
if (isAutonomous)
{
if (!a.Inventory.ContainsType(typeof(Jetpack), 0x1))
{
return(false);
}
}
else if (a.GetActiveJetpack() == null)
{
return(false);
}
/*
* if (a.SimDescription.IsVisuallyPregnant)
* {
* greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString(a.SimDescription.IsFemale, "Gameplay/ActorSystems/OccultImaginaryFriend:ImaginaryFriendModeDisabledPregnancy", new object[] { a.SimDescription }));
* return false;
* }
*/
SocialJig socialjig = null;
if (!Jetpack.CheckSpaceForFlyAroundJig(a, target, ref socialjig, true, true))
{
greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString("Gameplay/Objects/EP11/Jetpack:NotEnoughSpace", new object[] { target }));
return(false);
}
return(true);
}
private void Start()
{
GameObject player = GameObject.FindGameObjectWithTag("Player");
jetpack = player.GetComponentInChildren <Jetpack>();
slider.minValue = 0f;
slider.maxValue = jetpack.maxCharge;
}
// Update is called once per frame
private void Update()
{
playerData.isFlying = false;
groundPoint = transform.position + playerData.groundOffset;
Vector3 velocity = Vector3.zero;
if (Input.GetKey(KeyCode.W) && playerData.isGrounded && !playerData.isFlying)
{
velocity += (playerData.speed * 10) * Vector3.up;
}
if (Input.GetKey(KeyCode.A))
{
velocity += playerData.speed * Vector3.left;
}
if (Input.GetKey(KeyCode.S))
{
velocity += playerData.speed * Vector3.down;
}
if (Input.GetKey(KeyCode.D))
{
velocity += playerData.speed * Vector3.right;
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
ChangeEquipment("Simple Jetpack");
}
if (Input.GetKey(KeyCode.Space))
{
// Jetpack
if (playerData.currentEquipable)
{
if (playerData.currentEquipable.type == EquipableType.Jetpack)
{
Jetpack jetpack = (Jetpack)playerData.currentEquipable;
if (!jetpack.isEmpty)
{
jetpack.UseFuel();
playerData.isFlying = true;
}
}
}
}
if (!playerData.isGrounded && !playerData.isFlying)
{
velocity += Vector3.down * 5.0f;
}
if (playerData.isFlying)
{
velocity += Vector3.up * 5.0f;
}
transform.position += velocity * Time.deltaTime;
//rb.velocity = velocity;
}
public bool TestUse(Jetpack obj)
{
if (!TestRepaired(obj))
{
return(false);
}
return(obj.UseCount == 0);
}
// Use this for initialization
void Start()
{
facing = GetComponent <Facing> ();
rb = GetComponent <Rigidbody2D> ();
pulse = GetComponent <Pulse> ();
surroundings = GetComponent <Surroundings> ();
jump = GetComponent <Jump> ();
jetpack = GetComponent <Jetpack> ();
playerInfo = GetComponent <Player> ();
}
void Start()
{
input = GetComponent <InputListener>();
jetpack = GetComponent <Jetpack>();
jetpackDustInitPos = jetpackDust.transform.localPosition;
anim = sprite.GetComponent <Animator>();
playerScript = GetComponent <ActorPlayer>();
CC = GetComponent <CharacterController2D>();
myHealth = GetComponent <PlayerHealth>();
}
void Grab()
{
RaycastHit hit;
if (Physics.Raycast(cam.transform.position, cam.transform.forward, out hit, rangegrab))
{
if (hit.collider.tag == "Objet" && objetoui == false)
{
hit.collider.tag = "Objet_active";
objetoui = true;
objet = hit.transform.GetComponent <Objet>();
if (fpsCam == true)
{
objet.transform.position = theDestfps.position;
objet.transform.parent = GameObject.Find("Destination_fps").transform;
}
if (tpsCam == true)
{
objet.transform.position = theDesttps.position;
objet.transform.parent = GameObject.Find("Destination_tps").transform;
}
}
if (hit.collider.tag == "Weapon" && oui == false)
{
hit.collider.tag = "Weapon_active";
oui = true;
arme = hit.transform.GetComponent <Weapon>();
if (fpsCam == true)
{
arme.transform.position = emplacement.position;
arme.transform.parent = GameObject.Find("Emplacement_arme").transform;
}
if (tpsCam == true)
{
arme.transform.position = emplacementtps.position;
arme.transform.parent = GameObject.Find("Emplacement_armetps").transform;
}
}
if (hit.collider.tag == "Jetpack" && jetpackOn == false)
{
jetpackOn = true;
jetpack = hit.transform.GetComponent <Jetpack>();
jetpack.transform.position = emplacementjetpack.position;
jetpack.transform.parent = GameObject.Find("Emplacement_jetpack").transform;
float yRotation = jetpack.player.transform.eulerAngles.y;
float xRotation = jetpack.player.transform.eulerAngles.x;
jetpack.transform.rotation = Quaternion.Euler(260 - xRotation, +yRotation + 180, 0);
jetpack.transform.GetComponent <Rigidbody>().useGravity = false;
jetpack.transform.GetComponent <BoxCollider>().enabled = false;
jetpack.transform.GetComponent <Rigidbody>().freezeRotation = true;
jetpack.transform.GetComponent <Rigidbody>().velocity = new Vector3(0, 0, 0);
}
}
}
private const float GroundedRadius = .05f; // Radius of the overlap circle to determine if grounded
protected void Awake()
{
PlayerState = new State {
Position = transform.localPosition
};
// Setting up references.
_groundCheck = transform.Find("GroundCheck");
_aiming = GetComponent <PlayerAiming>();
_jetpack = GetComponent <Jetpack>();
}
void Awake()
{
//Para test
//InitializeInputController (1);
//PlayerName = 1;
//isGamePad = false;
//fin para test
rbPlayer = GetComponent <Rigidbody2D>();
coll2d = new Collider2D[0];
jetpack = GetComponent <Jetpack>();
}
void Start()
{
Rigidbody = GetComponent <Rigidbody>();
jetPack = GetComponentInChildren <Jetpack>();
m_Cam = Camera.main.transform;
thirdPersonCamera = FindObjectOfType <ThirdPersonCamera>();
gameManager = GameObject.Find("GameManager").GetComponent <GameManager>();
animator = GetComponent <Animator>();
RespawnPosition = transform.position;
}
void Start()
{
input = GetComponentInParent <InputListener>();
r = GetComponent <SpriteRenderer>();
actorPlayer = GetComponentInParent <ActorPlayer>();
anim = GetComponent <Animator>();
cooldownCountdown = cooldown;
damageCountdown = 0;
jet = GetComponentInParent <Jetpack>();
//CC.GetComponentInParent<CharacterController2D>();
}
void Awake()
{
//PlayerWeaponsManager = GetComponentInParent<IS_PlayerWeaponsManager>();
//DebugUtility.HandleErrorIfNullFindObject<IS_PlayerWeaponsManager, NotificationHUDManager>(IS_PlayerWeaponsManager, this);
//PlayerWeaponsManager.onAddedWeapon += OnPickupWeapon;
Jetpack jetpack = FindObjectOfType <Jetpack>();
// DebugUtility.HandleErrorIfNullFindObject<Jetpack, NotificationHUDManager>(jetpack, this);
jetpack.onUnlockJetpack += OnUnlockJetpack;
}
// Use this for initialization
void Start()
{
launcher = GameObject.Find("PlayerThrower").GetComponent <Detach>();
player = GameObject.FindGameObjectWithTag("Player");
obstacleModifier = FindObjectOfType <Bounce>();
gameScore = FindObjectOfType <Score>();
booster = FindObjectOfType <Jetpack>();
openShop = GetComponent <AudioSource>();
upgradeScreen.SetActive(false);
}
void Start()
{
rb = GetComponent <Rigidbody2D>();
playerStates = PlayerStates.Instance;
playerMovement = GetComponent <PlayerMovement>();
playerSlopeMove = GetComponent <PlayerSlopeMove>();
jetpack = GetComponent <Jetpack>();
playerJump = GetComponent <PlayerJump>();
controller = GetComponent <PlayerCollisions>();
}
protected void GrantJetpack(Jetpack jetpack, Player player)
{
var oldJetpack = player.jetpackContainer.GetComponentInChildren <Jetpack>();
if (oldJetpack)
{
Destroy(oldJetpack.gameObject);
}
jetpack.transform.parent = player.jetpackContainer;
jetpack.transform.localPosition = Vector3.zero;
jetpack.transform.localRotation = Quaternion.identity;
}
void Awake()
{
PlayerWeaponsManager playerWeaponsManager = FindObjectOfType <PlayerWeaponsManager>();
DebugUtility.HandleErrorIfNullFindObject <PlayerWeaponsManager, NotificationHUDManager>(playerWeaponsManager, this);
playerWeaponsManager.onAddedWeapon += OnPickupWeapon;
Jetpack jetpack = FindObjectOfType <Jetpack>();
DebugUtility.HandleErrorIfNullFindObject <Jetpack, NotificationHUDManager>(jetpack, this);
jetpack.onUnlockJetpack += OnUnlockJetpack;
}
void Awake()
{
if (online)
{
m_Jetpack_Photon = managerOnline.m_Player.GetComponent <JetPack_Photon>();
}
else
{
m_Jetpack = managerOffile.m_Player.GetComponent <Jetpack>();
}
fillBarColorChange.Initialize(1f, 0f);
}
void OnCollisionEnter(Collision col)
{
if (col.collider.CompareTag("Player"))
{
GameObject player = col.gameObject;
if (type == EquipableType.Jetpack)
{
Jetpack pack = player.AddComponent <Jetpack>();
pack.AddToInventory(player.GetComponent <PlayerData>());
Destroy(this.gameObject);
}
}
}
void Start()
{
m_Animator = GetComponent <Animator>();
m_Rigidbody = GetComponent <Rigidbody>();
m_Capsule = GetComponent <CapsuleCollider>();
m_CapsuleHeight = m_Capsule.height;
m_CapsuleCenter = m_Capsule.center;
jetpack = GetComponentInChildren <Jetpack>();
m_Rigidbody.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationY | RigidbodyConstraints.FreezeRotationZ;
m_OrigGroundCheckDistance = m_GroundCheckDistance;
}
void Start()
{
jetpack = GameObject.FindGameObjectWithTag("JetpackComplete");
jetpackScript = GetComponentInChildren <Jetpack>();
cam = Camera.main;
cc = GetComponent <CharacterController>();
firedParticle = Resources.Load <GameObject>("P_GunfireParent");
potato = Resources.Load <GameObject>("Prefab_Potato");
trajectory = gameObject.AddComponent <LineRenderer>();
trajectory.positionCount = trajectorySegments;
trajectory.startWidth = 0.10f;
trajectory.endWidth = 0.10f;
trajectory.material = Resources.Load <Material>("M_Trajectory");
animations = GetComponent <Animations>();
shootLocation = GameObject.FindGameObjectWithTag("Shootlocation").transform;
potatoCannon = GameObject.FindGameObjectWithTag("PotatoCannon");
thrusters = new ParticleSystem[2];
foundParticleSystems = gameObject.GetComponentsInChildren <ParticleSystem>();
for (int i = 0; i < foundParticleSystems.Length; i++)
{
if (foundParticleSystems[i].tag == "Jetpack")
{
thrusters[amountOfThrusters] = foundParticleSystems[i];
amountOfThrusters++;
}
}
foreach (var thruster in thrusters)
{
thruster.Stop();
}
health = GetComponent <Health>();
Physics.IgnoreLayerCollision(11, 9);
jetpack.SetActive(GameManager.hasJetpack);
inCharSelect = SceneManager.GetActiveScene().name == "Scene_CharacterSelect";
if (!inCharSelect)
{
Cursor.visible = false;
}
}
void Update()
{
if (desiredPlayer != null)
{
m_Jetpack = desiredPlayer.GetComponent <Jetpack>();
}
mainCanvasGroup.gameObject.SetActive(m_Jetpack.isJetpackUnlocked);
if (m_Jetpack.isJetpackUnlocked)
{
jetpackFillImage.fillAmount = m_Jetpack.currentFillRatio;
fillBarColorChange.UpdateVisual(m_Jetpack.currentFillRatio);
}
}
public override void Start () {
base.Start ();
foreach (Gadget gadget in this.GetComponentsInChildren<Gadget>())
gadget.owner = this;
this.jetpack = this.GetComponentInChildren<Jetpack> ();
//TODO Implement gravity.
testingGravity = this.gameObject.AddComponent<ConstantForceField>() ;
testingGravity.val = new Vector2(0,-gravityVal) ;
testingGravity.RegisterMover (this);
this.prevMouseLocation = Input.mousePosition;
}
void Awake()
{
PlayerWeaponsManager playerWeaponsManager = FindObjectOfType <PlayerWeaponsManager>();
DebugUtility.HandleErrorIfNullFindObject <PlayerWeaponsManager, NotificationHUDManager>(playerWeaponsManager,
this);
playerWeaponsManager.OnAddedWeapon += OnPickupWeapon;
Jetpack jetpack = FindObjectOfType <Jetpack>();
DebugUtility.HandleErrorIfNullFindObject <Jetpack, NotificationHUDManager>(jetpack, this);
jetpack.OnUnlockJetpack += OnUnlockJetpack;
EventManager.AddListener <ObjectiveUpdateEvent>(OnObjectiveUpdateEvent);
}
void Start()
{
IsFacingRight = true;
jetpack = GetComponentInChildren <Jetpack>();
boxCollider = GetComponent <BoxCollider2D>();
animatorController = GetComponent <AnimatorController>();
float colliderWidthNoSkin = boxCollider.size.x * Mathf.Abs(transform.localScale.x) - 2 * skinWidth;
float colliderHeightNoSkin = boxCollider.size.y * Mathf.Abs(transform.localScale.y) - 2 * skinWidth;
horizontalDistanceBetweenRays = colliderWidthNoSkin / (totalVerticalRays - 1);
verticalDistanceBetweenRays = colliderHeightNoSkin / (totalHorizontalRays - 1);
}
void OnTriggerEnter2D(Collider2D other)
{
if (other.tag == "Player")
{
characterSwitch activeCharacter = FindObjectOfType <characterSwitch>();
if (activeCharacter.activeCharacterIndex == 0)
{
Jetpack jetpack = other.transform.GetComponent <Jetpack>();
if (jetpack.fuelLevel < 100)
{
FindObjectOfType <AudioManager>().Play("Smokes");
jetpack.fuelLevel = Mathf.Clamp(jetpack.fuelLevel + fuelToAdd, 0, 100);
Destroy(gameObject);
}
}
}
}
void Start()
{
deathFX.SetActive(false);
grindFX.SetActive(false);
currLife = Life;
lifeText.text = "Life: " + currLife + "/" + Life;
jp = GetComponent <Jetpack>();
im = GetComponent <Impactor>();
pu = GetComponent <PickUp>();
sw = GetComponent <soundWaveScript>();
rn = GetComponentInChildren <Renderer>();
rb = GetComponent <Rigidbody>();
cl = GetComponent <Collider>();
}
private void Start()
{
base.Start();
canInput = true;
boostRecharging = false;
boosting = false;
currentGroundPoundDuration = 0.0f;
boostCharge = maxBoostCharge;
playerAnimator = GetComponent <Animator>();
playerSprite = GetComponent <SpriteRenderer>();
ability = GetComponent <Abilities>();
jetPack = GetComponent <Jetpack>();
playerHUD = HUD.instance;
playerHUD.powerupImage.sprite = abilityIcons[0];
}
void Start()
{
// Script attached to Player object
controller = GetComponent<Controller2D>();
gravity = -(2 * maxJumpHeight) / Mathf.Pow(timeToJumpApex, 2);
maxJumpVelocity = Mathf.Abs(gravity) * timeToJumpApex;
minJumpVelocity = Mathf.Sqrt(2 * Mathf.Abs(gravity) * minJumpHeight);
//print("Gravity: " + gravity + " Jump Velocity: " + maxJumpVelocity);
// Start player off with a full jetpack
jetpack = GetComponent<Jetpack>();
jetpack.Fill();
// Button Assignment object
keyAssign = FindObjectOfType<KeyAssign>();
// Set Quick Fire Special move to disabled so it can be called at a later time
quickFire = GetComponent<QuickFireManager>();
quickFire.enabled = false;
anim = GetComponent<Animator>();
}
public override string GetInteractionName(Sim actor, Jetpack target, InteractionObjectPair iop)
{
return base.GetInteractionName(actor, target, new InteractionObjectPair(sOldSingleton, target));
}
public override void AddInteractions(InteractionObjectPair iop, Sim actor, Jetpack target, List<InteractionObjectPair> results)
{
results.Add(new InteractionObjectPair(new Definition(false), target));
results.Add(new InteractionObjectPair(new Definition(true), target));
}
void Awake()
{
Helper.TestFunction();
S = this;
}
// Use this for initialization
void Start()
{
_controller = GetComponent<CharacterController>();
_jetpack = GetComponent<Jetpack>();
}
