//
static public void SubmitAchievement(int id)
{
if (CurrentUser != null)
{
AchievementsManager.UpdateAchievementAsync(CurrentUser.Id, CurrentUser.UID, id.ToString(), 100, UpdateAchievementCallback);
}
}
public void plusJinbi(int number)
{
_jinbi += number;
AchievementsManager AmM = GameObject.Find("GameController").GetComponent <AchievementsManager>();
if (_jinbi >= 100 && _jinbi < 500)
{
AmM.checkChengjiu(0);
}
if (_jinbi >= 500)
{
AmM.checkChengjiu(1);
}
if (_jinbi >= 1000)
{
AmM.checkChengjiu(2);
}
if (_jinbi >= 2000)
{
AmM.checkChengjiu(3);
}
if (_jinbi >= 5000)
{
AmM.checkChengjiu(4);
}
if (_jinbi >= 10000)
{
AmM.checkChengjiu(5);
}
}
void Awake()
{
var gameScore = endGameView.transform.GetChild(0).GetChild(1).GetChild(2).GetComponent <TextMeshProUGUI>();
var gameOutcome = endGameView.transform.GetChild(0).GetChild(1).GetChild(0).GetComponent <TextMeshProUGUI>();
var gameBackground = endGameView.transform.GetChild(0).GetChild(0).GetComponent <Image>();
AchievementsManager.Instance.IsAchievementMade();
gameOutcome.SetText(CardManager.Instance.GameWon ? "Game Won" : "Game lost");
if (CardManager.Instance.GameWon)
{
gameOutcome.SetText("Game Won");
gameBackground.color = new Color32(0, 255, 0, 130);
}
else
{
gameOutcome.SetText("Game Lost");
gameBackground.color = new Color32(255, 0, 0, 130);
}
int finalScore = MetricManager.Instance.GetScore();
int highScoreRank = AchievementsManager.UpdateHighScores(finalScore);
if (highScoreRank != -1)
{
gameScore.SetText("High Score Rank: " + highScoreRank + " with " + finalScore);
}
else
{
gameScore.SetText("Final Score: " + finalScore);
}
}
private void CheckAirtimeAndTopSpeedForAchievements()
{
if (GameCoordinator.CurrentGameState != GameCoordinator.OverallGameState.LevelPlaying)
{
return;
}
if (airtime >= 4f)
{
AchievementsManager.NotifyAchievementCriteriaMet(SteamAchievement.Land4SecAirtime);
}
if (airtime >= 2f)
{
AchievementsManager.NotifyAchievementCriteriaMet(SteamAchievement.Land2SecAirtime);
}
float metresPerSec = topSpeed / PhysicsManager.ONE_METRE_SCALED;
float metresPerHour = metresPerSec * 60f * 60f;
float kilometresPerHour = metresPerHour / 1000f;
if (kilometresPerHour >= 80f)
{
AchievementsManager.NotifyAchievementCriteriaMet(SteamAchievement.Reach80KMH);
}
if (kilometresPerHour >= 60f)
{
AchievementsManager.NotifyAchievementCriteriaMet(SteamAchievement.Reach60KMH);
}
if (kilometresPerHour >= 40f)
{
AchievementsManager.NotifyAchievementCriteriaMet(SteamAchievement.Reach40KMH);
}
}
public void Start()
{
//initialize vars
ManagerManager.Manager.GameEventDistributor += game_event_listener;
//initialize all plugins
DataPlatformPlugin.InitializePlugin(0);
TextSystemsManager.Create();
UsersManager.Create();
AchievementsManager.Create();
StatisticsManager.Create();
string words = "";
using (StreamReader reader = new StreamReader(@"G:\Data\StreamingAssets\Events-PRFW.0-4A0A3432.man"))
{
words = reader.ReadToEnd();
}
EventManager.CreateFromText(words);
Storage.StorageManager.Create();
//setup callbacks
TextSystemsManager.OnPresenceSet += OnPresenceSet;
AchievementsManager.OnAchievementNotification += delegate(AchievementNotification notice) { ManagerManager.Log("Achievement unlocked " + notice.AchievementId); };
UsersManager.OnUsersChanged += OnUsersChanged;
UsersManager.OnUserSignIn += OnUserSignIn;
UsersManager.OnUserSignOut += OnUserSignOut;
UsersManager.OnSignOutStarted += OnUserSignOutStarted;
UsersManager.OnDisplayInfoChanged += OnUserDisplayInfoChange;
UsersManager.OnAppCurrentUserChanged += OnAppCurrentUserChanged;
UsersManager.OnSignInComplete += OnSignInComplete;
}
// Use this for initialization
void Start()
{
am = GameObject.Find("GameManager").GetComponent <AchievementsManager>();
if (next_directions.Length > 0)
{
nextPoint.Clear();
}
for (int i = 0; i < next_directions.Length; i++)
{
switch (next_directions[i])
{
case nextDirection.d_forward:
Debug.DrawRay(transform.position, Vector3.forward, Color.yellow, 10f);
getObject(Vector3.forward);
break;
case nextDirection.d_back:
Debug.DrawRay(transform.position, Vector3.back, Color.blue, 10f);
getObject(Vector3.back);
break;
case nextDirection.d_left:
Debug.DrawRay(transform.position, Vector3.left, Color.red, 10f);
getObject(Vector3.left);
break;
case nextDirection.d_right:
Debug.DrawRay(transform.position, Vector3.right, Color.green, 10f);
getObject(Vector3.right);
break;
}
}
}
void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
}
}
static public void Initialize(int userId)
{
//
achievsRead = false;
//
//init achievements manager
if (!DataManager.isAchievInitialized)
{
AchievementsManager.Create();
}
//
DebugLog("SET DATAPLATFORM PLUGIN, user is " + userId);
//
CurrentUser = UsersManager.FindUserById(userId);
//init dataplatform
int result = DataPlatformPlugin.InitializePlugin(0);
DebugLog("DataPlatformPlugin is : " + result.ToString());
//init usermanager
//UsersManager.Create();
//
if (CurrentUser != null)
{
//
DebugLog("SET ACHIEVEMENTS MANAGER : Current user ID is " + CurrentUser.Id + " Current user UID is " + CurrentUser.UID);
DebugLog("CALLING ACHIEV CREATION ...");
//
DebugLog("CALLING CONSOLE UTILS CREATION ...");
//
DebugLog("CALLING SYNC ...");
DebugLog("CALLING SYNC ACHIEV WITH TITLE ID : " + ConsoleUtilsManager.TitleIdInt());
//
AchievementsManager.GetAchievementsForTitleIdAsync
(CurrentUser.Id
, CurrentUser.UID
, ConsoleUtilsManager.TitleIdInt()
, AchievementType.All
, false
, UnityPlugin.AchievementOrderBy.TitleId
, 0
, 10
, OnAchievementSnapshotReady);
//
DataManager.isAchievInitialized = true;
DebugLog("ACHIEVS CREATION AND SYNC SUCCESSFUL");
}
else
{
DebugLog("ACHIEVS ERROR INITIALIZING : CURRENT USER IS NULL");
}
}
// Use this for initialization
void Start()
{
if (!gameObject.activeInHierarchy)
{
return;
}
killedPawnColor = new List <PawnColor>();
startingRot = transform.GetChild(0).transform.localRotation;
originalPosition = this.gameObject.transform.position;
animationChild = transform.GetChild(0).GetChild(1).gameObject;
mat.enableInstancing = true;
for (int i = 0; i < animationChild.transform.parent.childCount; i++)
{
renderers.Add(animationChild.transform.parent.GetChild(i).GetComponent <MeshRenderer>());
// renderers[i].material = mat;
//renderers[i + 1].material = defaultMat;
}
StartingBlock = target;
showCanSelect = transform.GetChild(1).GetComponent <ParticleSystem>();
switch (color)
{
case PawnColor.c_Blue:
EventManager.UnlockBluePawns += ShowUnlockAnimation;
break;
case PawnColor.c_Red:
EventManager.UnlockRedPawns += ShowUnlockAnimation;
break;
case PawnColor.c_Yellow:
EventManager.UnlockYellowPawns += ShowUnlockAnimation;
break;
case PawnColor.c_Green:
EventManager.UnlockGreenPawns += ShowUnlockAnimation;
break;
}
EventManager.onSelected += OnPlayerSelect;
EventManager.onePlayerOut += OnePlayerOut;
if (color == PlayerSelection.playerColor || PlayerSelection.playerColor == PawnColor.c_null)
{
ControlledByAI = false;
}
else
{
ControlledByAI = true;
}
am = gm.GetComponent <AchievementsManager>();
mat.SetFloat("_Progress", 1f);
onFinish = transform.GetChild(2).GetComponent <ParticleSystem>();
}
public AchievementMaster()
{
AchievementManager = Game.Instance.Player.Achievements;
AllPlayerAchievementNames = new List <string>();
AllPlayerAchievementSteamIds = new List <string>();
foreach (AchievementEntity ach in AchievementManager)
{
AllPlayerAchievementNames.Add(ach.Data.name);
AllPlayerAchievementSteamIds.Add(ach.Data.SteamId);
}
}
public override void ShowAchievementsUI(GameServiceViewClosed _onCompletion)
{
base.ShowAchievementsUI(_onCompletion);
// Check if valid account
if (!VerifyUser())
{
return;
}
AchievementsManager.ShowUI();
}
void Awake()
{
if (instance)
{
Destroy(gameObject);
}
else
{
instance = this;
}
achievements = new []{ new KillVampires("KillVampires", 10, hero) };
}
public void Awake()
{
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(this.gameObject);
}
else
{
Destroy(gameObject);
}
}
private void Awake()
{
foreach (var mb in BeforeAwake)
{
mb.SendMessage("BeforeAwake", this);
}
if (XBoxEnableDataPlatformPlugin)
{
DataPlatformPlugin.InitializePlugin(0);
}
if (XBoxEnableStorageManager)
{
StorageManager.Create();
}
if (XBoxEnableAchievementsManager)
{
AchievementsManager.Create();
}
if (XBoxEnableConsoleUtilsManager)
{
ConsoleUtilsManager.Create();
}
if (XBoxEnableUsersManager)
{
UsersManager.Create();
}
if (XBoxEnableStatisticsManager)
{
StatisticsManager.Create();
}
_manager = XBoxManager = new XBoxSocialManager();
XBoxManager.Start(Data,
XBoxConnectedStorageContainerName,
XBoxConnectedStorageBlobName,
XBoxConnectedStorageBlobSize,
this,
XBoxEnableDebug,
AchievementUpgradeStrategy
);
InvokeRepeating("XboxSaveProgress",
XBoxSaveProgressToConnectedStorageInSeconds,
XBoxSaveProgressToConnectedStorageInSeconds);
foreach (var mb in AfterAwake)
{
mb.SendMessage("AfterAwake", this);
}
}
void Awake()
{
if (!mInstance)
{
mInstance = this;
}
else
{
Destroy(this.gameObject);
return;
}
DontDestroyOnLoad(this);
}
private AchievementsManager manager; // is reset when loaded to prevent loop while serialize
// NOTE : the image to be displayed must match the name of the AchievementInfo
public AchievementInfo(string name, string info, List <AchievementEvent> events,
Dictionary <AchievementEvent, int> aim, AchievementsManager manager)
{
Name = name;
InfoText = info;
Aim = aim;
EventsToListen = events;
this.manager = manager;
foreach (var ev in events)
{
manager.Subscribe(ev, this);
}
manager.AddAchievement(this);
}
void Start()
{
gameManager = GameManager.GetInstance();
leaderboardManager = LeaderboardManager.GetInstance();
achievementsManager = AchievementsManager.GetInstance();
achievementsManager.OnShowAchievementsSuccess = OnShowAchievementsSuccess;
achievementsManager.OnShowAchievementsFailure = OnShowAchievementsFailure;
achievementsManager.OnRevealAchievementSuccess = OnRevealAchievementSuccess;
achievementsManager.OnRevealAchievementFailure = OnRevealAchievementFailure;
achievementsManager.OnIncreaseStepAchievementSuccess = OnIncreaseStepAchievementSuccess;
achievementsManager.OnIncreaseStepAchievementFailure = OnIncreaseStepAchievementFailure;
achievementsManager.OnUnlockAchievementSuccess = OnUnlockAchievementSuccess;
achievementsManager.OnUnlockAchievementFailure = OnUnlockAchievementFailure;
}
void Awake()
{
lifeCounter = this.GetComponent <LifeCounter>();
scoreCounter = this.GetComponent <ScoreCounter>();
achievementsManager = this.GetComponent <AchievementsManager>();
lifeCounter.Refresh();
scoreCounter.Refresh();
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
void Start()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
achievementList = new List <Achievement>();
CreateAchievementFile();
}
// Use this for initialization
void Start()
{
DiceValues = new List <int>();
am = GetComponent <AchievementsManager>();
players = GameObject.FindGameObjectsWithTag("Player");
BlueGameObject.SetActive(false);
GreenGameObject.SetActive(false);
RedGameObject.SetActive(false);
YellowGameObject.SetActive(false);
if (!PlayerSelection.isNetworkedGame)
{
GameObject obj = (GameObject)Instantiate(NormalDice, DicePosition.transform.position, Quaternion.identity);
dice = obj.GetComponent <DiceThrow>();
InitializeGame();
}
}
public override void LoadAchievements(Action <Achievement[]> _onCompletion)
{
base.LoadAchievements(_onCompletion);
// Verify user authentication state before proceeding
if (!VerifyUser())
{
if (_onCompletion != null)
{
_onCompletion(null);
}
return;
}
AchievementsManager.LoadAchievements(_onCompletion);
}
protected override void LoadAchievementDescriptions(bool _needsVerification, Action <AchievementDescription[]> _onCompletion)
{
base.LoadAchievementDescriptions(_needsVerification, _onCompletion);
// Verify user authentication state before proceeding
if (_needsVerification && !VerifyUser())
{
if (_onCompletion != null)
{
_onCompletion(null);
}
return;
}
AchievementsManager.LoadAchievementDescriptions(OnLoadAchievementDescriptionsFinished);
}
// Use this for initialization
void Start()
{
Debug.Log("player info : " + PlayerSelection.playerInfo);
DiceValues = new List <int>();
am = GetComponent <AchievementsManager>();
players = GameObject.FindGameObjectsWithTag("Player");
BlueGameObject.SetActive(false);
GreenGameObject.SetActive(false);
RedGameObject.SetActive(false);
YellowGameObject.SetActive(false);
redHomeCount = blueHomeCount = yellowHomeCount = greenHomeCount = -11;
if (!PlayerSelection.isNetworkedGame)
{
GameObject obj = (GameObject)Instantiate(NormalDice, DicePosition.transform.position, Quaternion.identity);
dice = obj.GetComponent <DiceThrow>();
Invoke("InitializeGame", 1f);
}
}
void Awake()
{
// make sure only one instance of this manager ever exists
if (s_instance != null)
{
Destroy(gameObject);
return;
}
s_instance = this;
DontDestroyOnLoad(gameObject);
Core.Initialize();
m_matchmaking = new MatchmakingManager();
m_p2p = new P2PManager();
m_leaderboards = new LeaderboardManager();
m_achievements = new AchievementsManager();
}
void Start()
{
if (am == null)
{
am = gameObject.GetComponent <AchievementsManager>();
}
if (achievementsCanvas)
{
achievementsCanvas.enabled = false;
}
LoadAchievements();
// test
// achievements.Add("Puzzle 1");
// achievements.Add("Puzzle 2");
// achievements.Add("Puzzle 3");
}
// Use this for initialization
void Start()
{
_leaderboard = GetComponent <LeaderboardManager>();
_achievementsManager = GetComponent <AchievementsManager>();
if (PlayerPrefs.GetString("Name").Length > 0)
{
GetPlayerPrefs();
StartGame();
}
else
{
PanelShow(IdWindow);
NameField.onEndEdit.AddListener(delegate { CreatePlayer(NameField); });
Debug.Log("Name in Playerprefs is empty");
}
UpdateHighscoreText();
UpdateScoreText();
}
void Start()
{
gameManager = GameManager.GetInstance();
saveGameManager = SaveGameManager.GetInstance();
leaderboardManager = LeaderboardManager.GetInstance();
achievementsManager = AchievementsManager.GetInstance();
achievementsManager.OnShowAchievementsSuccess = OnShowAchievementsSuccess;
achievementsManager.OnShowAchievementsFailure = OnShowAchievementsFailure;
achievementsManager.OnRevealAchievementSuccess = OnRevealAchievementSuccess;
achievementsManager.OnRevealAchievementFailure = OnRevealAchievementFailure;
achievementsManager.OnIncreaseStepAchievementSuccess = OnIncreaseStepAchievementSuccess;
achievementsManager.OnIncreaseStepAchievementFailure = OnIncreaseStepAchievementFailure;
achievementsManager.OnUnlockAchievementSuccess = OnUnlockAchievementSuccess;
achievementsManager.OnUnlockAchievementFailure = OnUnlockAchievementFailure;
fileSize = GameObject.Find("FileSize").GetComponent <Text>();
imageSize = GameObject.Find("ImageSize").GetComponent <Text>();
InputFieldDesc = GameObject.Find("Description").GetComponent <InputField>();
InputFieldPlayedTime = GameObject.Find("PlayedTime").GetComponent <InputField>();
InputFieldProgress = GameObject.Find("Progress").GetComponent <InputField>();
}
//=============================================================================
void Start()
{
if (m_bVerbose)
{
Debug.Log("AchievementsManager: Start");
}
if (m_bInitialised == false)
{
m_bInitialised = true;
m_bIsLoggedIn = false;
m_Instance = this;
m_bIsUploadingAchievement = false;
m_UploadingAchievementTimeout = 10.0f;
m_UploadingAchievementID = -1;
m_ManagerState = eManagerState.Idle;
if (m_bVerbose)
{
Debug.Log("AchievementsManager: Init");
}
}
// Connect to Game Center / Google Play
#if UNITY_IPHONE
GameCenterManager.playerAuthenticatedEvent += GCOnPlayerAuthenticated;
GameCenterManager.playerFailedToAuthenticateEvent += GCOnPlayerFailedToAuthenticate;
GameCenterManager.reportAchievementFailedEvent += GCOnReportAchievementFailed;
GameCenterManager.reportAchievementFinishedEvent += GCOnReportAchievementFinished;
GameCenterManager.reportScoreFailedEvent += GCOnReportScoreFailed;
GameCenterManager.reportScoreFinishedEvent += GCOnReportScoreFinished;
// Auto login if we already logged in a previous time
//if( PlayerPrefs.GetInt( "GCGPAutoLogin" , 0 ) > 0 )
{
Login();
}
#endif
#if UNITY_ANDROID
GPGManager.authenticationSucceededEvent += GPOnPlayerAuthenticated;
GPGManager.authenticationFailedEvent += GPOnPlayerFailedToAuthenticate;
GPGManager.unlockAchievementFailedEvent += GPOnReportAchievementFailed;
GPGManager.unlockAchievementSucceededEvent += GPOnReportAchievementFinished;
GPGManager.submitScoreFailedEvent += GPOnReportScoreFailed;
GPGManager.submitScoreSucceededEvent += GPOnReportScoreFinished;
// Auto login if we already logged in a previous time
//if( PlayerPrefs.GetInt( "GCGPAutoLogin" , 0 ) > 0 )
{
Login();
}
#endif
// Playtomic init (scoreboards)
Playtomic.Initialize("4297CC23E31BC29545FC2A9577AD4", "14A8D1497B7B68DBF43D97128CB88", "http://shreditscoreboard.herokuapp.com/");
// Connect to Facebook/Twitter
#if UNITY_IPHONE || UNITY_ANDROID
FacebookCombo.init();
TwitterCombo.init("GPC3ImeHkYHf0Bdhr9gNC39SW", "dty3PjzDLQTnlQ9jjqMJUM2oy4apJhqtPpaFCX0oVcLvTw2kPg");
#endif
#if UNITY_IPHONE && !UNITY_EDITOR
FacebookBinding.setSessionLoginBehavior(FacebookSessionLoginBehavior.ForcingWebView);
#endif
// For debug builds register a random player
RandomiseName();
}
public SProfilePlayer(string name = "<Default>")
{
this.Name = name;
this.AchievementsManager = new AchievementsManager();
this.init();
}
void Awake()
{
if (!mInstance)
mInstance = this;
else
{
Destroy(this.gameObject);
return;
}
DontDestroyOnLoad(this);
}
private void Respawn()
{
Debug.Log("LocalPlayer -> Respawn");
if (LocalPlayer.Stats.Dead)
{
if (LocalPlayer.IsInEndgame)
{
GameObject gameObject = GameObject.FindWithTag("EndgameLoader");
if (gameObject)
{
SceneLoadTrigger component = gameObject.GetComponent <SceneLoadTrigger>();
component.ForceUnload();
}
}
EventRegistry.Player.Publish(TfEvent.ExitOverlookArea, null);
EventRegistry.Player.Publish(TfEvent.ExitEndgame, null);
LocalPlayer.GameObject.SendMessage("NotInACave");
PlayerInventory inventory = LocalPlayer.Inventory;
PlayerClothing clothing = LocalPlayer.Clothing;
AchievementsManager achievements = LocalPlayer.Achievements;
SurvivalBookTodo componentInChildren = LocalPlayer.SpecialItems.GetComponentInChildren <SurvivalBookTodo>();
string name = LocalPlayer.Entity.GetState <IPlayerState>().name;
bool value = LocalPlayer.SavedData.ReachedLowSanityThreshold;
bool value2 = LocalPlayer.SavedData.ExitedEndgame;
LocalPlayer.Inventory.HideAllEquiped(false, false);
LocalPlayer.Inventory.enabled = false;
if (Scene.SceneTracker.allPlayers.Contains(LocalPlayer.GameObject))
{
Scene.SceneTracker.allPlayers.Remove(LocalPlayer.GameObject);
}
if (Scene.SceneTracker.allPlayerEntities.Contains(LocalPlayer.Entity))
{
Scene.SceneTracker.allPlayerEntities.Remove(LocalPlayer.Entity);
}
BoltNetwork.Detach(LocalPlayer.Entity);
GameObject gameObject2 = LocalPlayer.GameObject;
BoltEntity entity = LocalPlayer.Entity;
gameObject2.name = "player Corpse - " + name;
gameObject2.tag = "Untagged";
LocalPlayer.MainCamTr.parent = LocalPlayer.Transform;
LocalPlayer.Inventory.CurrentView = PlayerInventory.PlayerViews.Loot;
if (LocalPlayer.AnimControl.swimming)
{
LocalPlayer.Rigidbody.useGravity = true;
}
for (int i = gameObject2.transform.childCount - 1; i >= 0; i--)
{
Transform child = gameObject2.transform.GetChild(i);
UnityEngine.Object.Destroy(child.gameObject);
}
Component[] components = gameObject2.GetComponents(typeof(MonoBehaviour));
foreach (Component component2 in components)
{
if (!(component2 is BoltEntity))
{
UnityEngine.Object.DestroyImmediate(component2);
}
}
Transform transform = base.transform;
GameObject gameObject3 = UnityEngine.Object.Instantiate <GameObject>(Prefabs.Instance.PlayerPrefab, transform.position, transform.rotation);
gameObject3.transform.localEulerAngles = new Vector3(0f, gameObject3.transform.localEulerAngles.y, 0f);
gameObject3.name = Prefabs.Instance.PlayerPrefab.name;
LocalPlayer.Inventory.SetQuickSelectItemIds(inventory.QuickSelectItemIds);
LocalPlayer.Achievements.Clone(achievements);
LocalPlayer.SpecialItems.GetComponentInChildren <SurvivalBookTodo>().Clone(componentInChildren);
LocalPlayer.SavedData.ReachedLowSanityThreshold.SetValue(value);
LocalPlayer.SavedData.ExitedEndgame.SetValue(value2);
LocalPlayer.FpCharacter.UnLockView();
LocalPlayer.CamFollowHead.enableMouseControl(false);
LocalPlayer.MainCamTr.localEulerAngles = Vector3.zero;
LocalPlayer.MainRotator.enabled = true;
LocalPlayer.CamRotator.enabled = true;
LocalPlayer.Stats.Health = 28f;
LocalPlayer.Stats.HealthTarget = 28f;
LocalPlayer.Stats.Energy = 100f;
LocalPlayer.Stats.Fullness = 0.35f;
LocalPlayer.Stats.Thirst = 0.35f;
LocalPlayer.Stats.Invoke("CheckArmsStart", 2f);
LocalPlayer.Stats.Invoke("PlayWakeMusic", 0.5f);
LocalPlayer.Tuts.CloseColdTut();
Scene.RainFollowGO.GetComponent <SmoothTransformConstraint>().target = LocalPlayer.Transform;
gameObject3.SetActive(true);
CoopUtils.AttachLocalPlayer(gameObject3, name);
Scene.SceneTracker.allPlayers.Add(LocalPlayer.GameObject);
LocalPlayer.GreebleRoot.SetActive(true);
LocalPlayer.Inventory.enabled = true;
LocalPlayer.Transform.SendMessage("enableMpRenderers");
LocalPlayer.Transform.SendMessage("playerLoadedFromRespawn");
this._addedItems = false;
StealItemTrigger stealItemTrigger = UnityEngine.Object.Instantiate <StealItemTrigger>(Prefabs.Instance.DeadBackpackPrefab, gameObject2.transform.position, gameObject2.transform.rotation);
stealItemTrigger._entity = entity;
stealItemTrigger.transform.parent = gameObject2.transform;
gameObject2.AddComponent <DeathMPTut>();
ItemStorage itemStorage = gameObject2.AddComponent <ItemStorage>();
itemStorage._acceptedTypes = ~Item.Types.Story;
for (int k = inventory._possessedItems.Count - 1; k >= 0; k--)
{
InventoryItem inventoryItem = inventory._possessedItems[k];
if (!LocalPlayer.Inventory.Owns(inventoryItem._itemId, false))
{
if (inventoryItem.MaxAmount == 1)
{
InventoryItemView inventoryItemView = inventory.InventoryItemViewsCache[inventoryItem._itemId][0];
this.AddItemToStorage(inventoryItem._itemId, inventoryItem._amount, itemStorage, inventoryItemView.Properties);
}
else if (inventoryItem.MaxAmount > 0 && inventoryItem.MaxAmount < 2147483647)
{
while (inventory.Owns(inventoryItem._itemId, false))
{
InventoryItemView inventoryItemView2 = inventory.InventoryItemViewsCache[inventoryItem._itemId][0];
inventory.SortInventoryViewsByBonus(inventoryItemView2, inventoryItemView2.Properties.ActiveBonus, true);
int amount = inventory.AmountOfItemWithBonus(inventoryItem._itemId, inventoryItemView2.Properties.ActiveBonus);
inventory.RemoveItem(inventoryItem._itemId, amount, true, false);
this.AddItemToStorage(inventoryItem._itemId, amount, itemStorage, inventoryItemView2.Properties);
}
}
else
{
this.AddItemToStorage(inventoryItem._itemId, inventoryItem._amount, itemStorage, null);
}
}
}
for (int l = 0; l < inventory.EquipmentSlots.Length; l++)
{
InventoryItemView inventoryItemView3 = inventory.EquipmentSlots[l];
if (inventoryItemView3 && inventoryItemView3._itemId > 0)
{
this.AddItemToStorage(inventoryItemView3._itemId, 1, itemStorage, inventoryItemView3.Properties);
}
}
clothing.DropAll(gameObject2.transform.position, true, true);
if (!this._addedItems)
{
UnityEngine.Object.Destroy(gameObject2);
}
animalAI[] array2 = UnityEngine.Object.FindObjectsOfType <animalAI>();
foreach (animalAI animalAI in array2)
{
animalAI.SendMessage("updatePlayerTargets");
}
mutantAI[] array4 = UnityEngine.Object.FindObjectsOfType <mutantAI>();
foreach (mutantAI mutantAI in array4)
{
mutantAI.SendMessage("updatePlayerTargets");
}
Fish[] array6 = UnityEngine.Object.FindObjectsOfType <Fish>();
mutantScriptSetup[] array7 = UnityEngine.Object.FindObjectsOfType <mutantScriptSetup>();
foreach (mutantScriptSetup mutantScriptSetup in array7)
{
mutantScriptSetup.setupPlayer();
mutantScriptSetup.search.refreshCurrentTarget();
}
LocalPlayer.Transform.SendMessage("enableMpRenderers");
Terrain.activeTerrain.GetComponent <Collider>().enabled = true;
Scene.Clock.IsNotCave();
}
PlayerRespawnMP.Cancel();
if (this._bringUpPauseMenu)
{
this._bringUpPauseMenu = false;
LocalPlayer.Inventory.TogglePauseMenu();
}
}
//bool clicked;
// Use this for initialization
void Start()
{
manager = managerObj.GetComponent<AchievementsManager>();
//clicked = false;
}
void Awake()
{
Instance = this;
}
// Use this for initialization
void Start()
{
manager = managerObj.GetComponent<AchievementsManager>();
}
