void Start()
{
highScore = PlayerPrefs.GetInt("highScore");
if ((pro == null) && (GetComponent <ThePlayer>() != null))
{
pro = GetComponent <ThePlayer>();
}
else
{
Debug.LogWarning("Missing ThePlayer component. Please add one");
}
sceneNo = SceneManager.GetActiveScene().buildIndex;
// Lcomplete = GetComponent<App_Initialize>();
if (sceneNo == 0)
{
increaser = 150;
}
if (sceneNo == 1)
{
increaser = 200;
}
if (sceneNo == 2)
{
increaser = 250;
}
if (sceneNo == 0 && PlayerPrefs.GetInt("level") != 1 && PlayerPrefs.GetInt("level") != 2)
{
PlayerPrefs.SetInt("level", 0);
}
// else if(keyPresent == false){
// PlayerPrefs.SetInt("level", 0);
// }
}
private void StartGame()
{
_gameHud.StartGame();
_loadScreen.HideLoadScreen();
GameMusic.PlaySound(GameMusicControl.GameTrack.Twinkly);
ThePlayer.SetMovementMode(FlapComponent.MovementMode.VerticalOnly);
}
public HighScoreWindow(int score)
{
InitializeComponent();
player = new ThePlayer(score);
textBlock.Text = textBlock.Text + score + " points!";
}
void OnPlayerCreation(Notification n)
{
int spawnAngle = 0;
int playerLabel = 0;
int traitor = Random.Range(0, 4);
for (int i = 0; i < numberOfPlayers; i++)
{
ThePlayer newPlayer = new ThePlayer();
newPlayer.HP = maxPlayerHP;
newPlayer.fireRate = defaultFireRate;
newPlayer.movementSpeed = defaultMovementSpeed;
if (i == traitor)
{
newPlayer.isTraitor = true;
}
else
{
newPlayer.isTraitor = false;
}
newPlayer.player = Instantiate(playerPrefab, spawnCentre);
newPlayer.player.transform.localPosition = new Vector3(playerSpawnRange, 0, 0);
spawnAngle += 90;
spawnCentre.transform.Rotate(new Vector3(0, spawnAngle, 0));
newPlayer.player.transform.SetParent(playerContainer);
newPlayer.player.transform.name = playerLabel.ToString();
PlayerDict.Add((playerLabel++).ToString(), newPlayer);
}
}
/// <summary>
/// Draw the map
/// </summary>
public void Draw()
{
Console.Clear();
var origRow = Console.CursorTop;
var origCol = Console.CursorLeft;
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Tiles[y, x].Draw();
}
Console.WriteLine();
}
Console.WriteLine($"Player {ThePlayer.Number} location: [{ThePlayer.X + 1}, {ThePlayer.Y + 1}]");
ThePlayer.Draw();
foreach (var m in Monsters)
{
m.Draw();
}
Console.SetCursorPosition(0, 0);
foreach (var m in Monsters)
{
m.PerformAI();
}
}
public override void Collision(Collision2D other)
{
ThePlayer.DeactivateRush();
if (other.collider.name == "StalObject")
{
other.collider.GetComponentInParent <Stalactite>().Crack();
}
if (ThePlayer.ActivateShield())
{
ThePlayer.PlaySound(ClumsyAudioControl.PlayerSounds.Collision); // TODO sounds
}
else
{
if (other.collider.name == "StalObject")
{
GameData.Instance.Data.Stats.ToothDeaths++;
}
else
{
//Level.Stats.RockDeaths++; // TODO check for other objects
}
ThePlayer.PlaySound(ClumsyAudioControl.PlayerSounds.Collision);
ThePlayer.Die();
}
}
private void ResumeGameplay()
{
_bPaused = false;
ThePlayer.PauseGame(false);
_gameHud.HideResumeTimer();
_gameHud.GamePaused(false);
PlayerController.ResumeGameplay();
}
protected override void AddDistance(float dist)
{
if (_caveHandler.IsGnomeEnding() && Level.AtCaveEnd() || !ThePlayer.GameHasStarted())
{
return;
}
base.AddDistance(dist);
}
public override void PauseGame(bool showMenu)
{
_bPaused = true;
ThePlayer.PauseGame(true);
_gameHud.GamePaused(true);
if (showMenu)
{
_gameMenu.PauseGame();
}
}
private void ResumeGameplay()
{
EventListener.ResumeGame();
Toolbox.Instance.GamePaused = false;
GameState = GameStates.Normal;
ThePlayer.PauseGame(false);
_gameHud.HideResumeTimer();
_gameHud.GamePaused(false);
PlayerController.ResumeGameplay();
}
private void CreateNewManager(object sender, RoutedEventArgs e)
{
Person manager = new Person()
{
Name = this.Name_TextBox.Text,
Surname = this.Surname_TextBox.Text,
BirthdayDate = this.Birthday_DatePicker.SelectedDate.Value,
Type = Person.PersonType.Manager,
};
ThePlayer player = new ThePlayer();
}
private static void PlayerTryMoveOffsetTo(int xoffset, int yoffset)
{
//this is the proposed new x,y of the player if move is successful.
int newx = ThePlayer.X + xoffset;
int newy = ThePlayer.Y + yoffset;
//perform boundary checking of new location, if it fails then we can't move there just because of boundary issues
if (newx > -1 && newx < Width && newy > -1 && newy < Height)
{
//get the tile that is at the new location
MapTile t = GetTileAtPos(newx, newy);
//if the space moving upwards is a blank space then move up
if (t.IsWalkable)
{
ThePlayer.Dirty = true;
Tiles[ThePlayer.Y, ThePlayer.X].IsWalkable = true; //the space we just moved from
ThePlayer.LastX = ThePlayer.X;
ThePlayer.LastY = ThePlayer.Y;
ThePlayer.X = newx;
ThePlayer.Y = newy;
Tiles[ThePlayer.Y, ThePlayer.X].IsWalkable = false; //make new tile not walkable because you are on it
CheckTileForAction(ThePlayer.X, ThePlayer.Y);
}
else
{
//if we can't walk onto this space then what is in this space? a wall, door, monster, etc.?
//walls do nothing, doors we can check for keys, monsters we attack.
var type = GetTileAtPos(newx, newy).GetType();
if (type == typeof(MapTileWall))
{
//do nothing, its a wall
}
else if (type == typeof(MapTileSpace))
{
//so if its a space and its not walkable, probably a monster here.
var monster = MonsterMgr.GetMonsterAt(newx, newy);
if (monster.IsAlive)
{
var maxdamage = ThePlayer.CanDealDamage();
//lets hit the monster for damage
monster.TakeDamage(maxdamage);
MessageBrd.Add($"Monster took {maxdamage} damage.");
if (!monster.IsAlive)
{
MessageBrd.Add($"Monster is DEAD!");
}
MonsterMgr.PruneDeadMonsters();
}
}
}
} // end of map boundary check
}
private void Update()
{
if (ThePlayer.IsAlive() && !Level.AtCaveEnd())
{
AddDistanceFromTime(Time.deltaTime);
}
if (PlayerController.State == GameStates.Normal && Level.AtCaveEnd())
{
ThePlayer.CaveEndReached();
}
}
/*
* @name CastPlayer()
* @purpose This downcasts the correct player to wether or not it is a human or computer.
*
* @return bool
*/
public void CastPlayer()
{
if (ThePlayer.GetType() == typeof(Human))
{
ThePlayer = (Human)ThePlayer;
}
else
{
ThePlayer = (Computer)ThePlayer;
}
}
public void MovePlayer(Point point)
{
if ((point.X < BoardWidth - 1 && point.X > 0) && (point.Y < BoardHeight - 1 && point.Y > 0))
{
ThePlayer.Move(point);
}
else
{
EndGame("You collided with the wall!");
}
}
public override void PauseGame(bool showMenu)
{
EventListener.PauseGame();
Toolbox.Instance.GamePaused = true;
GameState = GameStates.Paused;
ThePlayer.PauseGame(true);
_gameHud.GamePaused(true);
if (showMenu)
{
_gameMenu.PauseGame();
}
}
public void CheckCollisions()
{
if (PlayerOnFood())
{
Score += 100;
SpawnFood();
ThePlayer.Grow();
}
else if (PlayerOnPlayer())
{
EndGame("You collided with yourself!");
}
}
private IEnumerator BossEntrance()
{
_state = BossGameState.InBossRoom;
ThePlayer.EnableHover();
FindObjectOfType <SlidingDoors>().Close();
// TODO boss entrance sequence
yield return(new WaitForSeconds(2f));
ThePlayer.DisableHover();
BossEvents.BossFightStart();
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
base.OnNavigatedFrom(e);
var vm = DataContext as VideoPlayerViewModel;
if (vm != null)
{
vm.VideoStream = null;
}
ThePlayer.Dispose();
HlsPlayer.Dispose();
}
private IEnumerator LoadSequence()
{
yield return(new WaitForSeconds(1f));
StartGame();
yield return(ThePlayer.StartCoroutine("CaveEntranceAnimation"));
// TODO put this into a function that says "boss level begin" or something
GameState = GameStates.Normal;
_state = BossGameState.MovingTowardsBoss;
ThePlayer.SetPlayerSpeed(Toolbox.Instance.LevelSpeed);
PlayerController.EnterGamePlay();
}
public override bool FireEvent(Event E)
{
if (E.ID == "IdleQuery")
{
GameObject GO = E.GetParameter <GameObject>("Object");
// Check if the bed has an owner.
if (owner != string.Empty)
{
bool result = false;
// Allow the owner to use 'owner' labeled beds.
if (GO.Blueprint == owner)
{
result = true;
}
// Allow the faction to use 'faction' labeled beds.
foreach (KeyValuePair <string, int> item in GO.pBrain.FactionMembership)
{
if (item.Key == owner)
{
result = true;
}
}
// Stop the usage of the bedroll if this is not an owner.
if (result == false)
{
return(result);
}
}
// Debugging
if (debug)
{
string message = GO.DisplayName + " goes to bed!";
MessageQueue.AddPlayerMessage(message);
}
}
if (E.ID == "CommandSmartUse" && !ThePlayer.HasEffect("Sitting"))
{
// Check if the bed has an owner.
if (owner != string.Empty)
{
Popup.Show("The owner of this bed would be very cross if they caught you sleeping in it!");
return(false);
}
}
return(base.FireEvent(E));
}
/// <summary>
/// Add the player to the high scorers list.
/// Then uses the selection sort to sort the list.
/// </summary>
/// <param name="player"></param>
private void AddPlayerToList(ThePlayer player)
{
// Keep adding players until the list is full
if (currentIndex < highestPlayers.Length)
{
highestPlayers[currentIndex] = player;
currentIndex++;
}
// Once the list is full then lets find the player with the lowest score
// and replace them the with newest score.
else if (currentIndex == highestPlayers.Length)
{
int lowestIndex = 0;
for (int i = 0; i < highestPlayers.Length; i++)
{
if (highestPlayers[i].Score < highestPlayers[lowestIndex].Score)
{
lowestIndex = i;
}
}
if (highestPlayers[lowestIndex].Score < player.Score)
{
highestPlayers[lowestIndex] = player;
}
}
// SELECTION SORT //
ThePlayer tmp;
int min = 0;
for (int j = 0; j < highestPlayers.Length - 1; j++)
{
min = j;
if (highestPlayers[j] != null)
{
for (int k = j + 1; k < highestPlayers.Length; k++)
{
if (highestPlayers[k] != null && highestPlayers[k].Score > highestPlayers[min].Score)
{
min = k;
}
}
tmp = highestPlayers[min];
highestPlayers[min] = highestPlayers[j];
highestPlayers[j] = tmp;
}
}
}
private IEnumerator LevelStartAnimation()
{
yield return(new WaitForSeconds(LevelStartupTime));
Level.GameMenu.RemoveLoadingOverlay();
yield return(null);
ThePlayer.StartFog();
ThePlayer.StartCoroutine("CaveEntranceAnimation");
const float timeToReachDest = 0.6f;
yield return(new WaitForSeconds(timeToReachDest));
LevelStart();
}
private IEnumerator UpdateResumeTimer()
{
float waitTime = Level.GameMenu.RaiseMenu();
yield return(new WaitForSeconds(waitTime));
_resumeTimerStart = Time.time;
while (ThePlayer.IsAlive() && _resumeTimerStart + ResumeTimer - waitTime > Time.time)
{
float timeRemaining = _resumeTimerStart + ResumeTimer - Time.time;
Level.GameHud.SetResumeTimer(timeRemaining);
yield return(null);
}
ResumeGameplay();
}
public override void TriggerEntered(Collider2D other)
{
switch (other.name)
{
case "MothTrigger":
other.GetComponentInParent <Moth>().ConsumeMoth();
break;
case "ExitTrigger":
ThePlayer.ExitAutoFlightReached();
break;
case "Spore":
ThePlayer.Fog.Minimise();
break;
}
}
void BuffStats(float buff, ThePlayer thisPlayer)
{
float ms = defaultMovementSpeed * buff;
float fr = defaultFireRate * buff;
GameObject player = PlayerDict[name].player;
bool it = PlayerDict[name].isTraitor;
PlayerDict.Remove(thisPlayer.player.name);
ThePlayer newPlayer = new ThePlayer();
newPlayer.player = player;
newPlayer.movementSpeed = ms;
newPlayer.fireRate = fr;
newPlayer.isTraitor = it;
PlayerDict.Add(thisPlayer.player.name, newPlayer);
}
public Game1()
{
Graphics = new GraphicsDeviceManager(this);
Graphics.IsFullScreen = false;
Graphics.SynchronizeWithVerticalRetrace = true;
Graphics.GraphicsProfile = GraphicsProfile.HiDef;
Graphics.PreferredBackBufferWidth = 1200;
Graphics.PreferredBackBufferHeight = 900;
Graphics.PreferMultiSampling = true; //Error in MonoGame 3.6 for DirectX, fixed for dev version.
Graphics.PreparingDeviceSettings += SetMultiSampling;
Graphics.ApplyChanges();
Graphics.GraphicsDevice.RasterizerState = new RasterizerState(); //Must be after Apply Changes.
IsFixedTimeStep = false;
Content.RootDirectory = "Content";
FPSTimer = new Timer(this, 1);
Player = new ThePlayer(this);
Background = new Background(this, Player);
Enemies = new EnemyControl(this, Player);
Houses = new HouseControl(this, Player);
}
private void MoveClumsy(float time)
{
const float manualCaveScale = 0.8558578f;
float distToTravel = Toolbox.TileSizeX * manualCaveScale + 1f;
if (ThePlayer.IsPerched())
{
return;
}
float dist = time * ThePlayer.GetPlayerSpeed();
if (_distTravelled + dist > distToTravel)
{
dist = distToTravel - _distTravelled;
ThePlayer.SetMovementMode(FlapComponent.MovementMode.HorizontalEnabled);
StartCoroutine("BossEntrance");
}
_distTravelled += dist;
ThePlayer.transform.position += Vector3.right * dist;
_playerCam.transform.position += Vector3.right * dist;
ThePlayer.Lantern.transform.position += Vector3.right * dist;
}
/* Monitor enemy alive states */
void Update()
{
bool anyAlive = false;
bool anySpawned = false;
ThePlayer playerRef = null;
foreach (EnemyAI anEnemy in levelEnemies)
{
if (anEnemy != null)
{
anySpawned = true;
}
if (anEnemy != null && !anEnemy.isDead)
{
anyAlive = true;
}
if (anEnemy != null)
{
playerRef = anEnemy.player.GetComponent <ThePlayer>();
}
}
if (!anyAlive)
{
ScoreManager.Instance.FreezeScore();
}
if (!anySpawned)
{
ScoreManager.Instance.ShowNextLevelPrompt();
foreach (GameObject bullet in GameObject.FindGameObjectsWithTag("Bullet"))
{
Destroy(bullet);
}
}
if (playerRef != null)
{
playerRef.isInvincible = !anyAlive;
}
}
/// <summary>
/// Draw the map
/// </summary>
public int Update()
{
var origRow = Console.CursorTop;
var origCol = Console.CursorLeft;
if (NeedsRedrawing)
{
Console.Clear();
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Tiles[y, x].Draw();
}
Console.WriteLine(); //carriage return at end of each line because we're not using SetCursorPosition.
}
NeedsRedrawing = false;
}
//if there is a keypress available to capture, take it and perform its action
if (Console.KeyAvailable)
{
var ch = Console.ReadKey(true).Key;
switch (ch)
{
case ConsoleKey.Escape:
Log.Information("User is quitting.");
return(-1);
case ConsoleKey.UpArrow:
//perform boundary checking
if (ThePlayer.X > 0)
{
//if the space moving upwards is a blank space then move up
if (GetTileAtPos(ThePlayer.X, ThePlayer.Y - 1).IsWalkable)
{
MovePlayer(PlayerMovement.Up);
}
}
break;
case ConsoleKey.DownArrow:
if (ThePlayer.Y < Height - 1)
{
if (GetTileAtPos(ThePlayer.X, ThePlayer.Y + 1).IsWalkable)
{
MovePlayer(PlayerMovement.Down);
}
}
break;
case ConsoleKey.RightArrow:
if (ThePlayer.X < Width - 1)
{
if (GetTileAtPos(ThePlayer.X + 1, ThePlayer.Y).IsWalkable)
{
MovePlayer(PlayerMovement.Right);
}
}
break;
case ConsoleKey.LeftArrow:
if (ThePlayer.X > 0)
{
if (GetTileAtPos(ThePlayer.X - 1, ThePlayer.Y).IsWalkable)
{
MovePlayer(PlayerMovement.Left);
}
}
break;
}
}
//foreach player in players coming soon....
ThePlayer.Update();
MonsterMgr.UpdateAll(this);
MessageBrd.Update();
Console.SetCursorPosition(0, 0);
return(0);
}
// ------------------------------------------------------------------------------------------------------
// Called from Unity when player clicks on this floor tile
public void OnMouseUpAsButton()
{
// Pathfind to this clicked floor tile.
ThePlayer.PathfindToFloorTile(this);
}
/// <summary>
/// Draw the map
/// </summary>
static public int Update()
{
if (ThePlayer.Life < 1)
{
Console.Clear();
MessageBrd.Add($"You have DIED!");
MessageBrd.Update();
return(-1);
}
var origRow = Console.CursorTop;
var origCol = Console.CursorLeft;
UpdateFogOfWar();
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Tiles[y, x].Draw();
}
}
Dirty = false;
//foreach player in players coming soon....
ThePlayer.Update();
MonsterMgr.UpdateAll();
MessageBrd.Update();
ScoreCard.Update();
//if there is a keypress available to capture, take it and perform its action
if (Console.KeyAvailable)
{
var ch = Console.ReadKey(true).Key;
switch (ch)
{
case ConsoleKey.Escape:
Log.Information("User is quitting.");
return(-1);
case ConsoleKey.F2:
CheatToggleFOW();
break;
case ConsoleKey.UpArrow:
PlayerTryMoveOffsetTo(0, -1);
break;
case ConsoleKey.DownArrow:
PlayerTryMoveOffsetTo(0, 1);
break;
case ConsoleKey.RightArrow:
PlayerTryMoveOffsetTo(1, 0);
break;
case ConsoleKey.LeftArrow:
PlayerTryMoveOffsetTo(-1, 0);
break;
}
}
//Console.SetCursorPosition(0, 0);
return(0);
}
