private void Awake()
{
CurrentCheckpointPos = ServiceLocator.GetCheckpointService().GetNextCheckpoint(ref CheckpointNumber);
DTScriptManager = GetComponent <DTScriptManager>();
ServiceLocator.GetVoiceoverService().PlaySound(SoundType.TruckMovingNormal, 0);
}
internal static CheckpointEntity GetCheckpointEntity(CheckpointData checkpointData)
{
return(new CheckpointEntity(
checkpointData.Offset,
checkpointData.LastFailedRevivalTime.Match(v => v, () => (DateTime?)null),
checkpointData.UnhealthySince.Match(v => v, () => (DateTime?)null)));
}
internal CheckpointData CreateCheckpointData(bool updateClientModel)
{
// TODO: checkpoint resolver state.
var data = new CheckpointData
{
TrackbackList = string.Join("\n", this.trackbackList),
Timestamp = DateTime.UtcNow.ToString("yyyyMMdd/HHmmss", CultureInfo.InvariantCulture),
UpdateClientModel = updateClientModel
};
// store the model name
this.state.ModelName = $"{data.Timestamp}/model";
data.State = JsonConvert.SerializeObject(this.State);
this.trackbackList.Clear();
var modelId = Guid.NewGuid().ToString();
using (var memStream = new MemoryStream())
{
this.vw.ID = modelId;
this.vw.SaveModel(memStream);
data.Model = memStream.ToArray();
return(data);
}
}
public async Task CheckpointStoreBasicTest()
{
ICheckpointStore checkpointStore = CheckpointStore.Create(new StoreProvider(new InMemoryDbStoreProvider()));
for (long i = 0; i < 10; i++)
{
var checkpointData = new CheckpointData(i);
await checkpointStore.SetCheckpointDataAsync($"Endpoint{i}", checkpointData, CancellationToken.None);
}
IDictionary <string, CheckpointData> allCheckpointData = await checkpointStore.GetAllCheckpointDataAsync(CancellationToken.None);
Assert.Equal(10, allCheckpointData.Count);
long counter = 0;
foreach (KeyValuePair <string, CheckpointData> checkpointValue in allCheckpointData)
{
Assert.Equal(counter, checkpointValue.Value.Offset);
Assert.Equal($"Endpoint{counter}", checkpointValue.Key);
counter++;
}
for (long i = 0; i < 10; i++)
{
CheckpointData checkpointData = await checkpointStore.GetCheckpointDataAsync($"Endpoint{i}", CancellationToken.None);
Assert.NotNull(checkpointData);
Assert.Equal(i, checkpointData.Offset);
}
}
public void TruckLanded(object sender, TruckLandedEventArgs args)
{
transform.position = args.Target.position;
transform.rotation = args.Target.rotation;
CheckpointNumber = -1;
CurrentCheckpointPos = ServiceLocator.GetCheckpointService().GetNextCheckpoint(ref CheckpointNumber);
DTScriptManager.ToggleModelVisibility(true);
}
public Task <CheckpointData> GetCheckpointDataAsync(string id, CancellationToken token)
{
CheckpointData checkpointData = this.checkpointDatas.ContainsKey(id)
? this.checkpointDatas[id]
: new CheckpointData(Checkpointer.InvalidOffset);
return(Task.FromResult(checkpointData));
}
public void ClearCheckpoint(int sceneIndex)
{
CheckpointData data = new CheckpointData(sceneIndex);
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/checkpointdata.dat", FileMode.OpenOrCreate);
bf.Serialize(file, data);
file.Close();
}
public void SaveCheckpoint(Transform player, Transform checkpoint)
{
CheckpointData data = new CheckpointData(player, checkpoint, SceneManager.GetActiveScene().buildIndex);
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/checkpointdata.dat", FileMode.OpenOrCreate);
bf.Serialize(file, data);
file.Close();
}
public static CheckpointData[] ArrayOf(int size)
{
CheckpointData[] c = new CheckpointData[size];
for (int i = 0; i < size; ++i)
{
c[i] = new CheckpointData() { Id = i + 1, Respawns = 0, Time = TimeUtil.FormatTime(0), AverageFps = 0 };
}
return c;
}
// Input?
public void LoadLevel(int levelIndex)
{
p1Checkpoint = new CheckpointData();
p1Checkpoint.id = -1;
p2Checkpoint = new CheckpointData();
p2Checkpoint.id = -1;
StartCoroutine(TransitionController._GetInstance().Transition(levelIndex));
currentLevelIndex = levelIndex;
}
public static void SaveLevelCheckPointData(Checkpoint checkpointFile)
{
BinaryFormatter bf = new BinaryFormatter();
FileStream stream = new FileStream(Application.persistentDataPath + "/checkpoint.citrus", FileMode.Create);
CheckpointData data = new CheckpointData(checkpointFile);
bf.Serialize(stream, data);
stream.Close();
}
// called when OnTriggerEnter2D death box collider -> checkpoint object
public CheckpointData SaveData()
{
lastCheckpoint = new CheckpointData();
lastCheckpoint.musicClipTime = AudioController.Instance.MusicTime;
lastCheckpoint.playerPosition = playerObject.transform.position;
lastCheckpoint.playerVelocity = playerObject.GetComponent <Rigidbody2D>().velocity;
lastCheckpoint.cameraPosition = cameraViewport.position;
return(lastCheckpoint);
}
// Input?
public void EndLevel()
{
//For now, return to main menu
currentLevelIndex++;
StartCoroutine(TransitionController._GetInstance().Transition(currentLevelIndex));
p1Checkpoint = new CheckpointData();
p1Checkpoint.id = -1;
p2Checkpoint = new CheckpointData();
p2Checkpoint.id = -1;
}
public async Task AddEndpoint(string endpointId)
{
CheckpointData checkpointData = await this.checkpointStore.GetCheckpointDataAsync(endpointId, CancellationToken.None);
ISequentialStore <MessageRef> sequentialStore = await this.storeProvider.GetSequentialStore <MessageRef>(endpointId, checkpointData.Offset + 1);
if (this.endpointSequentialStores.TryAdd(endpointId, sequentialStore))
{
Events.SequentialStoreAdded(endpointId);
}
}
protected CacheCheckpointResult <T> CacheAfter(CheckpointData checkpoint, int lastSeen)
{
lock (checkpoint.SignalLock)
{
var cacheAfter = checkpoint.Cache.Where(x => x.Key > lastSeen);
return(new CacheCheckpointResult <T> {
LastId = cacheAfter.Count() == 0 ? Interlocked.CompareExchange(ref checkpoint.Checkpoint, 0, 0) : cacheAfter.Max(x => x.Key),
Data = cacheAfter.Select(x => x.Value.data).ToList()
});
}
}
private void LoadCheckpoint(CheckpointData data)
{
Debug.Log("restarting at last checkpoint!");
AudioController.Instance.MusicTime = data.musicClipTime;
AudioController.Instance.GetComponent <AudioSource>().Play();
playerObject.transform.position = data.playerPosition;
playerObject.GetComponent <Rigidbody2D>().velocity = data.playerVelocity;
cameraViewport.position = data.cameraPosition;
slidingScreen.GetComponent <ScreenSlider>().playerDead = false;
deathText.SetActive(false);
}
private IEnumerator DelaySpawn(GameObject player)
{
yield return(new WaitForSeconds(spawnDelay));
player.SetActive(true);
player.GetComponent <Body>().ResetAnimator();
CheckpointData p = player.GetComponent <Body>().playerID == 1 ? p1Checkpoint : p2Checkpoint;
int[] persistintLimbs = killStrayLimbs(player.GetComponent <Body>().playerID);
player.GetComponent <Body>().SetStartingLimbs(Mathf.Clamp(p.legCount - persistintLimbs[0], 0, 20), Mathf.Clamp(p.armCount - persistintLimbs[1], 0, 20), true);
}
private static void LoadMission(CheckpointData data)
{
var checkpoint = data.Checkpoint;
MySteamWorkshop.DownloadModsAsync(checkpoint.Mods, delegate(bool success, string mismatchMods)
{
if (success || (checkpoint.Settings.OnlineMode == MyOnlineModeEnum.OFFLINE) && MySteamWorkshop.CanRunOffline(checkpoint.Mods))
{
//Sandbox.Audio.MyAudio.Static.Mute = true;
MyScreenManager.CloseAllScreensNowExcept(null);
MyGuiSandbox.Update(VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_MILLISECONDS);
MyGuiScreenLoadSandbox.CheckMismatchmods(mismatchMods, callback : delegate(VRage.Game.ModAPI.ResultEnum val)
{
// May be called from gameplay, so we must make sure we unload the current game
if (MySession.Static != null)
{
MySession.Static.Unload();
MySession.Static = null;
}
//seed 0 has special meaning - please randomize at mission start. New seed will be saved and game will run with it ever since.
// if you use this, YOU CANNOT HAVE ANY PROCEDURAL ASTEROIDS ALREADY SAVED
if (checkpoint.Settings.ProceduralSeed == 0)
{
checkpoint.Settings.ProceduralSeed = MyRandom.Instance.Next();
}
MyGuiScreenGamePlay.StartLoading(delegate
{
checkpoint.Settings.Scenario = true;
MySession.LoadMission(data.SessionPath, checkpoint, data.CheckpointSize, data.PersistentEditMode);
});
});
}
else
{
MyLog.Default.WriteLine(MyTexts.Get(MyCommonTexts.DialogTextDownloadModsFailed).ToString());
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption : MyTexts.Get(MyCommonTexts.MessageBoxCaptionError),
messageText : MyTexts.Get(MyCommonTexts.DialogTextDownloadModsFailed),
buttonType : MyMessageBoxButtonsType.OK, callback : delegate(MyGuiScreenMessageBox.ResultEnum result)
{
if (MyFakes.QUICK_LAUNCH != null)
{
MyGuiScreenMainMenu.ReturnToMainMenu();
}
}));
}
MyLog.Default.WriteLine("LoadSession() - End");
});
}
public static CheckpointData[] Convert(MapMetaCheckpointData[] meta)
{
if (meta == null || meta.Length == 0)
{
return(null);
}
CheckpointData[] data = new CheckpointData[meta.Length];
for (int i = 0; i < meta.Length; i++)
{
data[i] = meta[i]?.Convert();
}
return(data);
}
public void SpawnPlayers()
{
m_players.ForEach(player => {
player.SetActive(true);
CheckpointData p = player.GetComponent <Body>().playerID == 1 ? p1Checkpoint : p2Checkpoint;
int[] persistintLimbs = killStrayLimbs(player.GetComponent <Body>().playerID);
player.GetComponent <Body>().SetStartingLimbs(Mathf.Clamp(p.legCount - persistintLimbs[0], 0, 20), Mathf.Clamp(p.armCount - persistintLimbs[1], 0, 20), true);
player.transform.position = p.pos;
});
//m_players.ForEach(player =>
//{
// RespawnPlayer(player);
//});
}
private void CreatePositionCheckpoint(Vector2 position)
{
var checkpointData = new CheckpointData()
{
Activated = true,
UsePosition = true,
Position = position,
MapEnemies = new List <Enemy>(_enemies.Select(enemy => enemy.Clone <Enemy>())),
MapCoins = new List <GameCoin>(_coins.Select(coin => coin.Clone())),
Ammo = PlayerManager.Instance.Ammo,
Coins = PlayerManager.Instance.Coins,
CoinsCollected = _coinsCollected
};
_lastCheckpoint = checkpointData;
}
public int GetCurrentSavedScene()
{
try {
if (File.Exists(Application.persistentDataPath + "/checkpointdata.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/checkpointdata.dat", FileMode.Open);
CheckpointData data = (CheckpointData)bf.Deserialize(file);
file.Close();
return(data.sceneIndex);
}
} catch {
}
return(-1);
}
private void Start()
{
Debug.Log("Initializing game.");
p1Checkpoint = new CheckpointData();
p1Checkpoint.id = -1;
p2Checkpoint = new CheckpointData();
p2Checkpoint.id = -1;
//remove additional Managers
GameManager[] managers = FindObjectsOfType <GameManager>();
if (managers.Length > 1)
{
Destroy(gameObject);
}
m_Instance = managers[0];
//start from menu or not
if (startFromMenu == true)
{
LoadLevel(1);
}
//create players, hide them and store them in m_players
m_players = new List <GameObject>();
if (playerprefab == null)
{
playerprefab = Resources.Load <GameObject>("Player");
}
GameObject p1 = Instantiate(playerprefab);
p1.GetComponent <Body>().playerID = 1;
p1.SetActive(false);
p1.name = "Player1";
m_players.Add(p1.gameObject);
GameObject p2 = Instantiate(playerprefab);
p2.GetComponent <Body>().playerID = 2;
p2.SetActive(false);
p2.name = "Player2";
m_players.Add(p2.gameObject);
}
private void Start()
{
if (initialize)
{
StartCoroutine(Load(1));
}
if (!data)
{
Debug.Log("New Data Instance created");
CheckpointData newCheckpointData = ScriptableObject.CreateInstance <CheckpointData>();
newCheckpointData.name = "Local " + System.DateTime.Now;
data = newCheckpointData;
if (initialize)
{
data.playerHealth = 100;
}
}
}
public static float[] LoadLevelCheckPointData()
{
if (File.Exists(Application.persistentDataPath + "/checkpoint.citrus"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream stream = new FileStream(Application.persistentDataPath + "/checkpoint.citrus", FileMode.Open);
CheckpointData data = bf.Deserialize(stream) as CheckpointData;
stream.Close();
return(data.CheckpointPos);
}
else
{
Debug.LogError("File Doesnt Exist from Serialize Load");
return(new float[3]);
}
}
// Input/Output?
public void SetCheckpoint(CheckpointData point, int playerID)
{
Debug.Log("Sets checkpoint for " + playerID);
switch (playerID)
{
case 1:
if (point.id > p1Checkpoint.id)
{
p1Checkpoint = point;
}
break;
case 2:
if (point.id > p2Checkpoint.id)
{
p2Checkpoint = point;
}
break;
}
}
public void LoadCheckpoint()
{
if (File.Exists(Application.persistentDataPath + "/checkpointdata.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/checkpointdata.dat", FileMode.Open);
CheckpointData data = (CheckpointData)bf.Deserialize(file);
file.Close();
Narrator narrator = GameObject.FindGameObjectWithTag("GameController").GetComponent <Narrator> ();
foreach (OneWayDoor door in OneWayDoor.instances)
{
door.loaded = false;
}
if (data.checkpoint)
{
Transform player = GameObject.FindGameObjectWithTag("Player").transform;
player.position = data.GetPlayerPosition();
player.GetComponent <PlayerController> ().SetRotation(data.GetPlayerRotation());
foreach (OneWayDoor door in OneWayDoor.instances)
{
if (door.transform.position.Equals(data.GetCheckpoinPosition()))
{
door.Close();
door.loaded = true;
if (door.playOnRestart)
{
narrator.Play(door.narration);
}
break;
}
}
}
else
{
if (narrator.playOnLoad != null)
{
narrator.Play(narrator.playOnLoad);
}
}
}
}
private void Update()
{
// Check if we need to change checkpoints
if ((transform.position - CurrentCheckpointPos.Pos).sqrMagnitude < CheckpointProximityThreshold)
{
CurrentCheckpointPos = ServiceLocator.GetCheckpointService().GetNextCheckpoint(ref CheckpointNumber);
}
Vector3 difference = transform.position - CurrentCheckpointPos.Pos;
// Rotate towards the checkpoint
Quaternion newQ = Quaternion.LookRotation(CurrentCheckpointPos.Pos - transform.position, Vector3.up);
transform.rotation = Quaternion.Lerp(transform.rotation, newQ, MaxRotationSpeed * Time.deltaTime);
CurrentMovementSpeed = Mathf.Max(0, Mathf.Min(CurrentMovementSpeed
+ (AccelerationSpeed - CurrentDecelerationSpeed) * Time.deltaTime, MaxMovementSpeed));
// Move forward.
transform.position += transform.forward * Time.deltaTime * CurrentMovementSpeed;
}
public void GetCheckpointDataTest()
{
var checkpointEntity1 = new CheckpointStore.CheckpointEntity(100, null, null);
CheckpointData checkpointData1 = CheckpointStore.GetCheckpointData(checkpointEntity1);
Assert.NotNull(checkpointData1);
Assert.Equal(100, checkpointData1.Offset);
Assert.False(checkpointData1.LastFailedRevivalTime.HasValue);
Assert.False(checkpointData1.UnhealthySince.HasValue);
DateTime lastFailedRevivalTime = DateTime.UtcNow;
DateTime unhealthySinceTime = DateTime.Parse("2008-05-01 7:34:42Z");
var checkpointEntity2 = new CheckpointStore.CheckpointEntity(100, lastFailedRevivalTime, unhealthySinceTime);
CheckpointData checkpointData2 = CheckpointStore.GetCheckpointData(checkpointEntity2);
Assert.NotNull(checkpointData2);
Assert.Equal(100, checkpointData2.Offset);
Assert.True(checkpointData2.LastFailedRevivalTime.HasValue);
Assert.Equal(lastFailedRevivalTime, checkpointData2.LastFailedRevivalTime.OrDefault());
Assert.True(checkpointData2.UnhealthySince.HasValue);
Assert.Equal(unhealthySinceTime, checkpointData2.UnhealthySince.OrDefault());
}
public new void Added(Scene scene)
{
orig_Added(scene);
Session session = (scene as Level)?.Session;
if (checkpoint != null || session == null || session.Area.GetLevelSet() == "Celeste")
{
return;
}
AreaKey area = session.Area;
ModeProperties mode = AreaData.Areas[area.ID].Mode[(int)area.Mode];
if (mode.Checkpoints == null)
{
return;
}
HashSet <string> cps = SaveData.Instance.GetCheckpoints(area);
CheckpointData cp = null;
foreach (CheckpointData checkpointData2 in mode.Checkpoints)
{
bool flag2 = session.LevelFlags.Contains(checkpointData2.Level) && cps.Contains(checkpointData2.Level);
if (flag2)
{
cp = checkpointData2;
}
}
string id = GetCheckpointPreviewName(area, cp?.Level);
if (MTN.Checkpoints.Has(id))
{
checkpoint = MTN.Checkpoints[id];
}
}
//for the convenience camera locked state
private static void InitCheck(int id, string name, float xloc, float yloc,
float xcam, float ycam, float orthosize)
{
CheckpointData data = new CheckpointData();
data.id = id;
data.name = name;
data.location = new Vector3 (xloc, yloc, 0f);
CameraFollowConfig camConfig = new CameraFollowConfig();
camConfig.isLocked = true;
camConfig.position = new Vector3(xcam, ycam, CameraFollow.camZCoordinate);
camConfig.lockedPosition = new Vector3(xcam, ycam, CameraFollow.camZCoordinate);
camConfig.orthoSize = orthosize;
data.camConfig = camConfig;
checkpointMapping[id] = data;
}
internal static void CleanupCheckpointState(string endpointId, CheckpointData checkpointData)
{
Log.LogDebug((int)EventIds.CleanupCheckpointState, Invariant($"Checkpoint for endpoint {endpointId} is {checkpointData.Offset}"));
}
private static void LoadMission(CheckpointData data)
{
var checkpoint = data.Checkpoint;
MySteamWorkshop.DownloadModsAsync(checkpoint.Mods, delegate(bool success,string mismatchMods)
{
if (success || (checkpoint.Settings.OnlineMode == MyOnlineModeEnum.OFFLINE) && MySteamWorkshop.CanRunOffline(checkpoint.Mods))
{
//Sandbox.Audio.MyAudio.Static.Mute = true;
MyScreenManager.CloseAllScreensNowExcept(null);
MyGuiSandbox.Update(VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_MILLISECONDS);
MyGuiScreenLoadSandbox.CheckMismatchmods(mismatchMods, callback: delegate(VRage.Game.ModAPI.ResultEnum val)
{
// May be called from gameplay, so we must make sure we unload the current game
if (MySession.Static != null)
{
MySession.Static.Unload();
MySession.Static = null;
}
//seed 0 has special meaning - please randomize at mission start. New seed will be saved and game will run with it ever since.
// if you use this, YOU CANNOT HAVE ANY PROCEDURAL ASTEROIDS ALREADY SAVED
if (checkpoint.Settings.ProceduralSeed == 0)
checkpoint.Settings.ProceduralSeed = MyRandom.Instance.Next();
MyGuiScreenGamePlay.StartLoading(delegate
{
checkpoint.Settings.Scenario = true;
MySession.LoadMission(data.SessionPath, checkpoint, data.CheckpointSize, data.PersistentEditMode);
});
});
}
else
{
MyLog.Default.WriteLine(MyTexts.Get(MyCommonTexts.DialogTextDownloadModsFailed).ToString());
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MyCommonTexts.DialogTextDownloadModsFailed),
buttonType: MyMessageBoxButtonsType.OK, callback: delegate(MyGuiScreenMessageBox.ResultEnum result)
{
if (MyFakes.QUICK_LAUNCH != null)
MyGuiScreenMainMenu.ReturnToMainMenu();
}));
}
MyLog.Default.WriteLine("LoadSession() - End");
});
}
private void CreatePositionCheckpoint(Vector2 position)
{
var checkpointData = new CheckpointData()
{
Activated = true,
UsePosition = true,
Position = position,
MapEnemies = new List<Enemy>(_enemies.Select(enemy => enemy.Clone<Enemy>())),
MapCoins = new List<GameCoin>(_coins.Select(coin => coin.Clone())),
Ammo = PlayerManager.Instance.Ammo,
Coins = PlayerManager.Instance.Coins,
CoinsCollected = _coinsCollected
};
_lastCheckpoint = checkpointData;
}
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
// Helpers
if (_stageCompleted)
_stageCompletedHelper.Update(gameTime);
_backgroundHelper.Update(_camera);
_pauseHelper.Update(gameTime);
if (_pauseHelper.Paused) return;
_time += gameTime.ElapsedGameTime.Duration();
DebugValues["Timer"] = _time.ToString();
_player.Update(gameTime, _stageCompleted);
if (_player.RequestRespawn)
HandlePlayerRespawn();
for (var i = 0; i < _projectiles.Count; i++)
{
_projectiles[i].Update(gameTime);
if (_projectiles[i].Subject == ProjectileSubject.FromEnemy && _projectiles[i].BoundingBox.Intersects(_player.BoundingRectangle))
_player.ReceiveAttack(_projectiles[i].Damage, _projectiles[i].LastPosition);
if (_projectiles[i].RequestErase)
_projectiles.Remove(_projectiles[i]);
}
for (var i = 0; i < _enemies.Count; i++)
{
_enemies[i].Update(gameTime);
if (_enemies[i].HasViewRange &&
_enemies[i].ViewRangeCooldown <= 0f &&
_camera.Contains(_enemies[i].BoundingRectangle) != ContainmentType.Disjoint &&
_enemies[i].ViewRange.Intersects(_player.BoundingRectangle))
{
_enemies[i].PlayerOnSight(_player.Position);
}
if (!_enemies[i].Dying && _enemies[i].ContactDamageEnabled && _enemies[i].BoundingRectangle.Intersects(_player.BoundingRectangle))
{
var lastHearts = _player.HP;
_player.ReceiveAttackWithRect(1, _enemies[i].BoundingRectangle);
if (lastHearts - _player.HP > 0)
_heartsLost += lastHearts - _player.HP;
}
for (var j = 0; j < _projectiles.Count; j++)
{
if (_projectiles[j].Subject == ProjectileSubject.FromPlayer)
{
if (!_enemies[i].Dying && !_enemies[i].IsImunity && _enemies[i].CanReceiveAttacks && _projectiles[j].BoundingBox.Intersects(_enemies[i].BoundingRectangle))
{
if (_enemies[i].EnemyType == EnemyType.TurtleWheel && _enemies[i].InWheelMode)
{
_projectiles[j].Acceleration = new Vector2(_projectiles[j].Acceleration.X * -1.7f, _rand.Next(-4, 5));
CreateSparkParticle(_projectiles[j].Position);
_projectiles[j].Subject = ProjectileSubject.FromEnemy;
}
else
{
_enemies[i].ReceiveAttack(_projectiles[j].Damage, _projectiles[j].LastPosition);
_projectiles[j].Destroy();
}
}
}
else if (_projectiles[j].BoundingBox.Intersects(_player.BoundingRectangle))
{
var lastHearts = _player.HP;
_player.ReceiveAttack(_projectiles[j].Damage, _projectiles[j].LastPosition);
if (lastHearts - _player.HP > 0)
_heartsLost += lastHearts - _player.HP;
_projectiles[j].Destroy();
}
if (_projectiles[j].RequestErase)
_projectiles.Remove(_projectiles[j]);
}
if (_enemies[i] is Boss)
{
var boss = (Boss)_enemies[i];
if (boss.RequestingHatDrop)
{
_player.PerformHatDrop();
}
if (boss.Collapsing)
{
SoundManager.SetBgmVolume(0.3f);
_ambienceSe.Volume = 0.3f;
}
}
if (_enemies[i].RequestErase)
{
_enemies.Remove(_enemies[i]);
_enemiesDefeated++;
}
}
for (var i = 0; i < GameMap.Instance.Spikes.Count; i++)
{
var spike = GameMap.Instance.Spikes[i];
if (_player.BoundingRectangle.Intersects(spike) && !_player.TouchedSpikes)
{
_heartsLost += _player.HP;
_player.CharacterSprite.RemoveImmunity();
_player.ReceiveAttackWithRect(999, spike);
_player.TouchedSpikes = true;
}
}
for (var i = 0; i < _coins.Count; i++)
{
_coins[i].Update(gameTime);
var sprite = _coins[i].CoinSprite;
if (sprite.TextureRegion.Name.IndexOf("CoinSparkle") > 0 && sprite.Looped)
{
_coins.Remove(_coins[i]);
}
else if (sprite.TextureRegion.Name.IndexOf("CoinSparkle") < 0 && _player.BoundingRectangle.Intersects(sprite.BoundingBox))
{
_coinsCollected += 1;
PlayerManager.Instance.AddCoins(1);
sprite.SetTexture(ImageManager.loadMisc("CoinSparkle"), false);
sprite.SetDelay(80);
SoundManager.PlaySafe(_coinsSe);
}
}
for (var i = 0; i < _shops.Count; i++)
{
if (_shops[i].IsActive && !_player.BoundingRectangle.Intersects(_shops[i].BoundingRectangle))
{
_shops[i].SetActive(false);
}
else if (!_shops[i].IsActive && _player.BoundingRectangle.Intersects(_shops[i].BoundingRectangle))
{
_shops[i].SetActive(true);
}
if (_shops[i].IsActive && _player.IsAttacking && !_shops[i].IsDenied())
{
_shops[i].SetArrowDenyState();
}
else if (_shops[i].IsDenied() && !_player.IsAttacking)
{
_shops[i].SetArrowNormalState();
}
_shops[i].Update(gameTime);
}
for (var i = 0; i < _checkpoints.Count; i++)
{
if (!_checkpoints[i].IsChecked && _player.BoundingRectangle.Intersects(_checkpoints[i].BoundingBox))
{
if (_checkpoints[i].IsEndFlag)
{
FinishStage(false);
}
else
{
_checkpoints[i].OnPlayerCheck();
var checkpointData = new CheckpointData()
{
Activated = true,
Checkpoint = _checkpoints[i],
MapEnemies = new List<Enemy>(_enemies.Select(enemy => enemy.Clone<Enemy>())),
MapCoins = new List<GameCoin>(_coins.Select(coin => coin.Clone())),
Ammo = PlayerManager.Instance.Ammo,
Coins = PlayerManager.Instance.Coins,
CoinsCollected = _coinsCollected
};
_lastCheckpoint = checkpointData;
}
}
_checkpoints[i].Update(gameTime);
}
UpdateCamera();
}
public void TakeCheckpoint(GameObject waypoint_to_restore)
{
int waypointIndex = GetWayPointIndex(waypoint_to_restore);
int preyprogress = waypointIndex != -1 ? waypointIndex : Mathf.FloorToInt(Prey.PathProgression);
lastCheckpoint = new CheckpointData()
{
PlayerPosition = Player.transform.position,
PreyProgress = preyprogress,
playerHealth = Player.GetComponent<PlayerScript>().health
};
}
