private void DotController_UpdateDotVisuals(On.RoR2.DotController.orig_UpdateDotVisuals orig, DotController self)
{
orig(self);
Items.MarwanAsh1.MysticsItemsMarwanAshHelper ashHelper = self.victimBody ? self.victimBody.GetComponent <Items.MarwanAsh1.MysticsItemsMarwanAshHelper>() : null;
if (ashHelper)
{
if (self.HasDotActive(ashDotIndex))
{
if (!ashHelper.burnEffectControllerStrong)
{
ModelLocator modelLocator = self.victimBody.modelLocator;
if (modelLocator && modelLocator.modelTransform)
{
ashHelper.burnEffectControllerStrong = self.victimBody.gameObject.AddComponent <BurnEffectController>();
ashHelper.burnEffectControllerStrong.effectType = ashBurnEffectParams;
ashHelper.burnEffectControllerStrong.target = modelLocator.modelTransform.gameObject;
}
}
}
else if (ashHelper.burnEffectControllerStrong)
{
Object.Destroy(ashHelper.burnEffectControllerStrong);
ashHelper.burnEffectControllerStrong = null;
}
}
}
/// <summary>
/// Can any friendly piece block the attacker?
/// </summary>
/// <param name="threateningPiece"></param>
/// <returns></returns>
private bool CanFriendlyPieceMoveBetweenKingAndAttacker(IPiece threateningPiece, IBoardState boardState)
{
switch (threateningPiece)
{
// all cases fall through
case IKnight _: // knights jump pieces, cannot move between
case IPawn _: // pawns attack in an adjacent square, cannot move between
case IKing _: // king will never be checking another king.
return(false);
}
foreach (IPiece piece in ActivePlayerPieces.Where(p => !(p is IKing) && p.Location != ChessPosition.None))
{
piece.GenerateMoves(boardState);
// use a copy of the MoveSet to prevent the collection from being modified in the following loop
IBoardState copyOfMoveSet = ModelLocator.BoardState;
copyOfMoveSet.Add(piece.MoveSet);
foreach (ChessPosition location in copyOfMoveSet)
{
var move = ModelLocator.CreateMove(piece.Location, location);
var isMoveLegal = IsMoveLegal(piece, move, boardState);
var isKingInCheckAfterMove = DoesPotentialMoveLeaveKingInCheck(move);
if (isMoveLegal && !isKingInCheckAfterMove)
{
return(true);
}
}
}
return(false);
}
void Start()
{
// Cache the user manager
this.userManager = ModelLocator.GetModelInstance <UserManager>() as UserManager;
this.cards = this.userManager.GetUserData().GetUserCards();
this.ConfirmButton.interactable = false;
}
private void ScaleBody()
{
if (this.sizeModifier == null)
{
return;
}
ModelLocator modelLocator = this.body.GetComponent <ModelLocator>();
if (modelLocator)
{
Transform modelTransform = modelLocator.modelBaseTransform;
if (modelTransform)
{
modelTransform.localScale *= this.sizeModifier.newSize;
if (this.sizeModifier.scaleCollider)
{
foreach (KinematicCharacterMotor kinematicCharacterMotor in this.body.GetComponentsInChildren <KinematicCharacterMotor>())
{
if (kinematicCharacterMotor)
{
kinematicCharacterMotor.SetCapsuleDimensions(kinematicCharacterMotor.Capsule.radius * this.sizeModifier.newSize, kinematicCharacterMotor.Capsule.height * this.sizeModifier.newSize, this.sizeModifier.newSize);
}
}
}
}
}
}
protected virtual void SetupModelLocator(GameObject prefab, Transform modelBaseTransform, Transform modelTransform)
{
ModelLocator modelLocator = prefab.GetComponent <ModelLocator>();
modelLocator.modelTransform = modelTransform;
modelLocator.modelBaseTransform = modelBaseTransform;
}
static void Main(string[] args)
{
var locator = new ModelLocator();
var tower = locator.Tower;
var warning = locator.WarnigService;
var factory = FlightFactory.Instance;
var webSocekt = locator.WebSocketService;
factory.SendFlightEvent += tower.AddFlight;
tower.OnPlaneReturn += factory.ReturnPlane;
webSocekt.onSetEmergency += warning.SetWarning;
webSocekt.onStopEmergency += warning.StopWarning;
webSocekt.StartConnection();
Console.WriteLine("Your air port was hosting to flights");
Console.ReadLine();
factory.SendFlightEvent -= tower.AddFlight;
tower.OnPlaneReturn -= factory.ReturnPlane;
webSocekt.onSetEmergency -= warning.SetWarning;
webSocekt.onStopEmergency -= warning.StopWarning;
webSocekt.Dispose();
Console.WriteLine("Host stop");
Console.ReadLine();
}
public override void OnExit()
{
base.OnExit();
if (controller.body)
{
ModelLocator modelLocator = controller.body.modelLocator;
if (modelLocator)
{
Transform modelTransform = modelLocator.modelTransform;
if (modelTransform)
{
HurtBoxGroup hurtBoxGroup = modelTransform.GetComponent <HurtBoxGroup>();
hurtBoxGroup.hurtBoxesDeactivatorCounter--;
}
}
if (NetworkServer.active)
{
Inventory inventory = controller.body.inventory;
float cooldown = CalculateCooldown(inventory ? inventory.GetItemCount(MysticsItemsContent.Items.MysticsItems_DasherDisc) : 1);
int cooldownSeconds = Mathf.CeilToInt(cooldown);
for (int i = 0; i < cooldownSeconds; i++)
{
controller.body.AddTimedBuff(MysticsItemsContent.Buffs.MysticsItems_DasherDiscCooldown, cooldown / (float)cooldownSeconds * (i + 1));
}
controller.body.ClearTimedBuffs(MysticsItemsContent.Buffs.MysticsItems_DasherDiscActive);
}
}
}
private void Start()
{
this.ShowButtons(true);
this.ShowSignupInputs(false);
this.userManager = ModelLocator.GetModelInstance <UserManager>() as UserManager;
this.battleManager = ModelLocator.GetModelInstance <BattleManager>() as BattleManager;
}
// Token: 0x06002B0F RID: 11023 RVA: 0x000B54AC File Offset: 0x000B36AC
private SkinnedMeshRenderer FindAttachedBodyMainRenderer()
{
if (!base.attachedBody)
{
return(null);
}
ModelLocator modelLocator = base.attachedBody.modelLocator;
CharacterModel.RendererInfo[] array;
if (modelLocator == null)
{
array = null;
}
else
{
CharacterModel component = modelLocator.modelTransform.GetComponent <CharacterModel>();
array = ((component != null) ? component.baseRendererInfos : null);
}
CharacterModel.RendererInfo[] array2 = array;
if (array2 == null)
{
return(null);
}
for (int i = 0; i < array2.Length; i++)
{
SkinnedMeshRenderer result;
if ((result = (array2[i].renderer as SkinnedMeshRenderer)) != null)
{
return(result);
}
}
return(null);
}
public void Start()
{
this.input = this.GetComponent <InputBankTest>();
this.ml = this.gameObject.GetComponent <ModelLocator>();
this.modelTransform = this.ml.modelTransform;
this.aa = this.modelTransform.GetComponent <AimAnimator>();
this.refCannonTransform = this.modelTransform;
this.cannonTransform = this.modelTransform.Find("CannonPivot");
this.headTransform = this.cannonTransform.Find("AncientWispArmature").Find("Head");
//this.headCollider = this.headTransform.GetComponent<Collider>();
//if( !this.headCollider || this.headCollider.enabled == false )
//{
// Main.LogW( "Head col not found, checking children" );
// this.headCollider = this.headTransform.GetComponentInChildren<Collider>();
// if( this.headCollider.enabled == false )
// {
// Main.LogW( "No enabled head colliders" );
// this.headCollider = null;
// }
//}
this.refHeadTransform = this.modelTransform;
this.baseCannonRot = this.cannonTransform.localRotation;
this.baseCannonPos = this.cannonTransform.localPosition;
this.baseHeadRot = this.headTransform.localRotation;
this.baseHeadPos = this.headTransform.localPosition;
this.offset1 = this.headTransform.position;
this.offset1 = this.modelTransform.InverseTransformPoint(this.offset1);
}
//Still Broken as hell
public void RunChestAnimation(EntityStates.Barrel.Opening self)
{
EntityState chestState = self.outer.GetComponent <EntityState>();
ModelLocator modelLocator = self.outer.GetComponent <ModelLocator>();
//protected void PlayAnimation(string layerName, string animationStateName, string playbackRateParam, float duration)
//"Body", "Opening", "Opening.playbackRate", Opening.duration
//Get Animator of the chest
Animator modelAnimator = modelLocator.modelTransform.GetComponent <Animator>();
if (modelAnimator)
{
//Play Animation
int layerIndex = modelAnimator.GetLayerIndex("Body");
modelAnimator.SetFloat("Opening.playbackRate", 1f);
modelAnimator.PlayInFixedTime("Opening", layerIndex, 0f);
modelAnimator.Update(0f);
float length = modelAnimator.GetCurrentAnimatorStateInfo(layerIndex).length;
modelAnimator.SetFloat("Opening.playbackRate", length / 1f);
}
if (chestState.sfxLocator)
{
Util.PlaySound(chestState.sfxLocator.openSound, base.gameObject);
}
}
void OnEnable()
{
//ContactDamageCooldown = ContactDamageCooldownFull;
characterBody = gameObject.GetComponent <CharacterBody>();
if (!characterBody)
{
_logger.LogError("No characterbody found for jammed enemy!");
return;
}
if (!characterBody.HasBuff(Shared.Buffs.BuffsController.Jammed))
{
characterBody.AddBuff(Shared.Buffs.BuffsController.Jammed);
}
if (characterBody.inventory && characterBody.inventory.GetItemCount(CurseController.isJammedItem) == 0)
{
characterBody.inventory.GiveItem(CurseController.isJammedItem);
}
ModelLocator modelLocator = gameObject.GetComponent <ModelLocator>();
if (modelLocator)
{
if (!fireEffect)
{
fireEffect = Object.Instantiate <GameObject>(instance.jammedFire, modelLocator.modelTransform.Find("ROOT").transform);
//fireEffect.transform.parent = modelLocator.modelTransform;
}
}
var deathBehaviour = gameObject.GetComponent <CharacterDeathBehavior>();
if (deathBehaviour)
{
characterDeathBehavior = deathBehaviour;
}
}
public void OnReceived()
{
GameObject clientGameObject = LocalUserManager.GetFirstLocalUser().cachedBodyObject;
GameObject gameObject = Util.FindNetworkObject(this.targetId);
ModelLocator modelLocator = gameObject.GetComponent <ModelLocator>();
ChildLocator childLocator = modelLocator.modelTransform.GetComponent <ChildLocator>();
ParticleSystem.EmissionModule particleSystemEmission = childLocator.FindChild("OverpowerParticles").GetComponent <ParticleSystem>().emission;
if (!gameObject)
{
UrsaPlugin.logger.LogMessage("Error syncing Ursa's glowing hands effect: target id game object was not found!");
return;
}
if (clientGameObject == gameObject)
{
return;
}
if (glow)
{
childLocator.FindChild("R_Hand").GetComponent <Light>().enabled = true;
childLocator.FindChild("L_Hand").GetComponent <Light>().enabled = true;
particleSystemEmission.enabled = true;
}
else
{
childLocator.FindChild("R_Hand").GetComponent <Light>().enabled = false;
childLocator.FindChild("L_Hand").GetComponent <Light>().enabled = false;
particleSystemEmission.enabled = false;
}
}
private static void SetupModelLocator(GameObject prefab, Transform modelBaseTransform, Transform modelTransform)
{
ModelLocator modelLocator = prefab.GetComponent <ModelLocator>();
modelLocator.modelTransform = modelTransform;
modelLocator.modelBaseTransform = modelBaseTransform;
}
private void Awake()
{
this.rb = this.GetComponent <Rigidbody>();
this.body = this.GetComponent <CharacterBody>();
this.motor = this.GetComponent <CharacterMotor>();
this.direction = this.GetComponent <CharacterDirection>();
this.modelLocator = this.GetComponent <ModelLocator>();
if (this.direction)
{
this.direction.enabled = false;
}
if (this.modelLocator)
{
if (this.modelLocator.modelTransform)
{
this.modelTransform = modelLocator.modelTransform;
this.originalRotation = this.modelTransform.rotation;
this.modelLocator.enabled = false;
}
}
if (this.motor)
{
this.gameObject.layer = LayerIndex.fakeActor.intVal;
this.motor.Motor.RebuildCollidableLayers();
}
}
// Token: 0x06001E0E RID: 7694 RVA: 0x0008D924 File Offset: 0x0008BB24
private void IgnoreCollisionsWithOwner()
{
if (this.owner)
{
ModelLocator component = this.owner.GetComponent <ModelLocator>();
if (component)
{
Transform modelTransform = component.modelTransform;
if (modelTransform)
{
HurtBoxGroup component2 = modelTransform.GetComponent <HurtBoxGroup>();
if (component2)
{
HurtBox[] hurtBoxes = component2.hurtBoxes;
for (int i = 0; i < hurtBoxes.Length; i++)
{
foreach (Collider collider in hurtBoxes[i].GetComponents <Collider>())
{
for (int k = 0; k < this.myColliders.Length; k++)
{
Collider collider2 = this.myColliders[k];
Physics.IgnoreCollision(collider, collider2);
}
}
}
}
}
}
}
}
public void Logout()
{
AuthenticationServiceClient client = new AuthenticationServiceClient();
OperationContextScope scope = new OperationContextScope(client.InnerChannel);
var prop = new HttpRequestMessageProperty();
prop.Headers.Add(HttpRequestHeader.Cookie, ModelLocator.getInstance().SessionModel.SessionCookie);
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = prop;
try
{
client.Logout();
mResponder.LogoutResult();
}
catch (FaultException <ONyRFaultException> ex)
{
mResponder.LogoutFault((ErrorCode)ex.Detail.ErrorCode);
}
catch (Exception)
{
mResponder.LogoutFault(ErrorCode.NonONyRError);
}
finally
{
if (client != null)
{
client.Close();
}
}
}
void Start()
{
// Cache the collider
this.boxCollider = this.GetComponent <BoxCollider>();
// Cache the battle manager
this.battleManager = ModelLocator.GetModelInstance <BattleManager>() as BattleManager;
}
private void RW_EditModelScale()
{
ModelLocator modelLocator = this.RW_body.GetComponent <ModelLocator>();
modelLocator.modelBaseTransform.gameObject.name = "ModelBase";
modelLocator.modelBaseTransform.localPosition = new Vector3(0f, 0.0f, 0f);
modelLocator.modelTransform.localScale = new Vector3(0.7f, 0.7f, 0.7f);
modelLocator.modelTransform.localPosition = new Vector3(0f, 0.2f, 0f);
}
public CharacterMaster SummonHeretic(GameObject summonerBodyObject, Vector3 spawnPosition)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'SummonHeretic(UnityEngine.GameObject)' called on client");
return(null);
}
MasterSummon masterSummon = new MasterSummon
{
masterPrefab = MasterCatalog.FindMasterPrefab("HereticMonsterMaster"),
position = spawnPosition,
rotation = Quaternion.identity,
summonerBodyObject = summonerBodyObject,
ignoreTeamMemberLimit = true,
useAmbientLevel = new bool?(true),
};
CharacterMaster characterMaster = masterSummon.Perform();
if (characterMaster)
{
GameObject bodyObject = characterMaster.GetBodyObject();
if (bodyObject)
{
ModelLocator component = bodyObject.GetComponent <ModelLocator>();
if (component && component.modelTransform)
{
TemporaryOverlay temporaryOverlay = component.modelTransform.gameObject.AddComponent <TemporaryOverlay>();
temporaryOverlay.duration = 0.5f;
temporaryOverlay.animateShaderAlpha = true;
temporaryOverlay.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
temporaryOverlay.destroyComponentOnEnd = true;
temporaryOverlay.originalMaterial = Resources.Load <Material>("Materials/matSummonDrone");
temporaryOverlay.AddToCharacerModel(component.modelTransform.GetComponent <CharacterModel>());
}
var inventory = characterMaster.inventory;
if (inventory)
{
inventory.CopyItemsFrom(summonerBodyObject.GetComponent <CharacterBody>().inventory);
}
}
}
if (characterMaster && characterMaster.bodyInstanceObject)
{
characterMaster.GetBody().AddTimedBuff(RoR2Content.Buffs.Immune, 3f);
GameObject gameObject = Resources.Load <GameObject>("Prefabs/Effects/HippoRezEffect");
if (gameObject)
{
EffectManager.SpawnEffect(gameObject, new EffectData
{
origin = spawnPosition,
rotation = characterMaster.bodyInstanceObject.transform.rotation
}, true);
}
}
return(characterMaster);
}
public void Update()
{
if (!body || !body.transform)
{
return;
}
if (NetworkServer.active)
{
if (target)
{
HealthComponent healthComponent = target.healthComponent;
if (!target.HasBuff(buffDef) || !healthComponent || !healthComponent.alive)
{
ClearTarget();
}
}
}
stopwatch += Time.deltaTime;
waveY = Mathf.Sin(stopwatch * Mathf.PI * waveFrequency + waveOffset * Mathf.PI * 2) * waveAmplitude;
if (target)
{
leash.leashOrigin = target.corePosition + offset * target.radius + Vector3.up * waveY;
rotateToDirection.targetRotation = Util.QuaternionSafeLookRotation(target.corePosition - transform.position);
}
else
{
leash.leashOrigin = body.corePosition + offset * body.radius + Vector3.up * waveY;
rotateToDirection.targetRotation = Quaternion.LookRotation(body.inputBank.aimDirection);
}
ItemDisplay itemDisplay = follower.GetComponent <ItemDisplay>();
ModelLocator modelLocator = body.modelLocator;
if (modelLocator)
{
Transform modelTransform = modelLocator.modelTransform;
if (modelTransform)
{
CharacterModel characterModel = modelTransform.GetComponent <CharacterModel>();
if (characterModel)
{
itemDisplay.SetVisibilityLevel(characterModel.visibility);
foreach (CharacterModel.RendererInfo rendererInfo in itemDisplay.rendererInfos)
{
Renderer renderer = rendererInfo.renderer;
renderer.GetPropertyBlock(materialPropertyBlock);
materialPropertyBlock.SetFloat("_Fade", target ? 1f : 1f / body.inventory.GetItemCount(MysticsItemsContent.Items.MysticsItems_Spotter));
renderer.SetPropertyBlock(materialPropertyBlock);
}
}
}
}
}
public void ModifyPasswordResult()
{
MessageBox.Show("A jelszó módosítása sikeres!", "Információ", MessageBoxButtons.OK);
if (ChangePasswordForm.hasInstance())
{
ChangePasswordForm.getCurrentInstance().Close();
}
ModelLocator.getInstance().SessionModel.NotifyOneOperationDone();
}
public MainForm()
{
InitializeComponent();
pnlHighlightedItemContainer = pnlOwnHighlightedItemContainer;
ModelLocator.getInstance().SessionModel.UpdateEvent += new Model.UpdateHandler(SessionModel_UpdateEvent);
ModelLocator.getInstance().SessionModel.Subscribe(this);
new LoginUserNotifier("adhie", "passbaze").Handle();
}
private void UpdateSingleTemporaryVisualEffect(ref TemporaryVisualEffect tempEffect, GameObject resource, float effectRadius, bool active, CharacterBody characterBody, string childLocatorOverride = "")
{
bool flag = tempEffect != null;
if (flag != active)
{
if (active)
{
if (!flag)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(resource, characterBody.corePosition, Quaternion.identity);
gameObject.SetActive(true);
tempEffect = gameObject.GetComponent <TemporaryVisualEffect>();
tempEffect.parentTransform = characterBody.coreTransform;
tempEffect.visualState = TemporaryVisualEffect.VisualState.Enter;
tempEffect.healthComponent = characterBody.healthComponent;
tempEffect.radius = effectRadius;
LocalCameraEffect component = gameObject.GetComponent <LocalCameraEffect>();
if (component)
{
component.targetCharacter = characterBody.gameObject;
}
if (!string.IsNullOrEmpty(childLocatorOverride))
{
ModelLocator modelLocator = characterBody.modelLocator;
ChildLocator childLocator;
if (modelLocator == null)
{
childLocator = null;
}
else
{
Transform modelTransform = modelLocator.modelTransform;
childLocator = ((modelTransform != null) ? modelTransform.GetComponent <ChildLocator>() : null);
}
ChildLocator childLocator2 = childLocator;
if (childLocator2)
{
Transform transform = childLocator2.FindChild(childLocatorOverride);
if (transform)
{
tempEffect.parentTransform = transform;
return;
}
}
}
}
}
else if (tempEffect)
{
tempEffect.visualState = TemporaryVisualEffect.VisualState.Exit;
}
}
}
private void Awake()
{
// Get all relevant components;
this.characterBody = this.gameObject.GetComponent <CharacterBody>();
this.model = this.gameObject.GetComponentInChildren <CharacterModel>();
this.modelSkinController = this.gameObject.GetComponentInChildren <ModelSkinController>();
this.childLocator = this.gameObject.GetComponentInChildren <ChildLocator>();
this.skillLocator = this.gameObject.GetComponentInChildren <SkillLocator>();
this.modelLocator = this.gameObject.GetComponent <ModelLocator>();
this.jetStopwatch = new Stopwatch();
}
private UserServiceClient GetClient()
{
UserServiceClient result = new UserServiceClient();
OperationContextScope scope = new OperationContextScope(result.InnerChannel);
var prop = new HttpRequestMessageProperty();
prop.Headers.Add(HttpRequestHeader.Cookie, ModelLocator.getInstance().SessionModel.SessionCookie);
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = prop;
return(result);
}
void Start()
{
// Cache the user and battle managers
this.userManager = ModelLocator.GetModelInstance <UserManager>() as UserManager;
this.battleManager = ModelLocator.GetModelInstance <BattleManager>() as BattleManager;
// Show stage start countdown overlay
this.ShowCountdownOverlay();
// Hide stage results overlay
this.ResultOverlay.SetActive(false);
}
private void ModifyModel()
{
// get model
CharacterModel model = null;
ModelLocator modelLocator = this.body.GetComponent <ModelLocator>();
if (modelLocator)
{
Transform modelTransform = modelLocator.modelTransform;
if (modelTransform)
{
model = modelTransform.GetComponent <CharacterModel>();
}
}
if (model)
{
if (this.materialReplacements == null)
{
this.materialReplacements = new MonsterMaterialReplacement[0];
}
if (this.meshReplacements == null)
{
this.meshReplacements = new MonsterMeshReplacement[0];
}
// replace materials
if (this.materialReplacements.Length > 0)
{
for (int i = 0; i < this.materialReplacements.Length; i++)
{
model.baseRendererInfos[this.materialReplacements[i].rendererIndex].defaultMaterial = this.materialReplacements[i].material;
}
if (body.name == "GolemBody(Clone)")
{
model.baseLightInfos[0].defaultColor = Color.blue;
}
}
// replace meshes
if (this.meshReplacements.Length > 0)
{
// only run this method on beetles- don't bother changing it for now since there's no other mesh replacements
this.FuckWithBoneStructure();
for (int i = 0; i < this.meshReplacements.Length; i++)
{
model.baseRendererInfos[this.meshReplacements[i].rendererIndex].renderer.GetComponent <SkinnedMeshRenderer>().sharedMesh = this.meshReplacements[i].mesh;
}
}
}
}
private void SwapSkills()
{
if (this.skillReplacements == null)
{
return;
}
SkillLocator skillLocator = this.body.skillLocator;
if (skillLocator)
{
for (int i = 0; i < skillReplacements.Length; i++)
{
switch (skillReplacements[i].skillSlot)
{
case SkillSlot.Primary:
skillLocator.primary.SetSkillOverride(this.gameObject, skillReplacements[i].skillDef, GenericSkill.SkillOverridePriority.Upgrade);
break;
case SkillSlot.Secondary:
skillLocator.secondary.SetSkillOverride(this.gameObject, skillReplacements[i].skillDef, GenericSkill.SkillOverridePriority.Upgrade);
break;
case SkillSlot.Utility:
skillLocator.utility.SetSkillOverride(this.gameObject, skillReplacements[i].skillDef, GenericSkill.SkillOverridePriority.Upgrade);
break;
case SkillSlot.Special:
skillLocator.special.SetSkillOverride(this.gameObject, skillReplacements[i].skillDef, GenericSkill.SkillOverridePriority.Upgrade);
break;
case SkillSlot.None:
//what are you actually trying to do here??
break;
}
// gotta add the missile launcher lmao- maybe a better system for this one day
if (this.skillReplacements[i].skillDef == Modules.Skills.missileLaunchDef)
{
ModelLocator modelLocator = this.body.GetComponent <ModelLocator>();
if (modelLocator)
{
Transform modelTransform = modelLocator.modelTransform;
if (modelTransform)
{
modelTransform.gameObject.AddComponent <AddMissileLauncherToLemurian>();
}
}
}
}
}
}
public void Start()
{
ModelLocator ml = this.GetComponent <ModelLocator>();
if (ml && ml.modelTransform)
{
this.target = ml.modelTransform.gameObject;
}
else
{
this.dead = true;
}
}
