538 lines
18 KiB
C#
538 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using Microsoft.Xna.Framework.Input;
|
|
using Revitalize.Framework.Minigame.SeasideScrambleMinigame;
|
|
using StardewValley;
|
|
using StardustCore.UIUtilities;
|
|
namespace Revitalize.Framework.Minigame.SeasideScrambleMinigame
|
|
{
|
|
/// <summary>
|
|
/// TODO: Finish character select screen.
|
|
/// -Make Sound effects happen
|
|
/// -make prompt for color selection
|
|
/// -a,d for keyboard
|
|
/// -dpad for p2-4
|
|
/// Also add interface for game entity for camera to consistently have a focus target.
|
|
/// -Make moving target enemies
|
|
/// -Make a sound effect play when they break
|
|
/// -Fix positioning of status effects on player HUD
|
|
/// -Add effect on player for a more visual representation of status effects.
|
|
///
|
|
/// -Make shooting gallary game mode
|
|
/// -Make shooting gallery map wider.
|
|
/// -Add in score system for shooting gallery mode.
|
|
///
|
|
/// -Make More guns
|
|
/// </summary>
|
|
public class SeasideScramble : StardewValley.Minigames.IMinigame
|
|
{
|
|
/// <summary>
|
|
/// A static reference to the game.
|
|
/// </summary>
|
|
public static SeasideScramble self;
|
|
|
|
public SeasideScrambleMap currentMap;
|
|
public Dictionary<string, SeasideScrambleMap> SeasideScrambleMaps;
|
|
|
|
public int currentNumberOfPlayers
|
|
{
|
|
get
|
|
{
|
|
return this.players.Count;
|
|
}
|
|
}
|
|
public const int maxPlayers = 4;
|
|
public Dictionary<SSCEnums.PlayerID, SSCPlayer> players;
|
|
|
|
public bool quitGame;
|
|
public Vector2 topLeftScreenCoordinate;
|
|
|
|
public SSCTextureUtilities textureUtils;
|
|
|
|
public SSCCamera camera;
|
|
|
|
public SSCMenus.SSCMenuManager menuManager;
|
|
|
|
public Vector2 oldMousePosition;
|
|
|
|
public SSCEntities.SSCEntityManager entities;
|
|
public SSCGuns.SSCGunManager guns;
|
|
|
|
public SSCFonts.SSCFont gameFont;
|
|
|
|
/// <summary>
|
|
/// The current game mode.
|
|
/// </summary>
|
|
public SSCEnums.SSCGameMode gameMode;
|
|
public bool friendlyFireEnabled;
|
|
|
|
/// <summary>
|
|
/// RNG.
|
|
/// </summary>
|
|
public Random random
|
|
{
|
|
get
|
|
{
|
|
return Game1.random;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constuctor.
|
|
/// </summary>
|
|
public SeasideScramble()
|
|
{
|
|
self = this;
|
|
this.camera = new SSCCamera();
|
|
//this.viewport = new xTile.Dimensions.Rectangle(StardewValley.Game1.viewport);
|
|
this.topLeftScreenCoordinate = new Vector2((float)(this.camera.viewport.Width / 2 - 384), (float)(this.camera.viewport.Height / 2 - 384));
|
|
|
|
this.LoadTextures();
|
|
|
|
this.entities = new SSCEntities.SSCEntityManager();
|
|
|
|
this.LoadMaps();
|
|
this.loadStartingMap();
|
|
this.quitGame = false;
|
|
|
|
this.players = new Dictionary<SSCEnums.PlayerID, SSCPlayer>();
|
|
//this.players.Add(SSCEnums.PlayerID.One, new SSCPlayer(SSCEnums.PlayerID.One));
|
|
//this.getPlayer(SSCEnums.PlayerID.One).setColor(Color.PaleVioletRed);
|
|
|
|
|
|
this.menuManager = new SSCMenus.SSCMenuManager();
|
|
|
|
this.menuManager.addNewMenu(new SSCMenus.TitleScreen(this.camera.viewport));
|
|
this.oldMousePosition = new Vector2(Game1.getMousePosition().X, Game1.getMousePosition().Y);
|
|
|
|
this.gameFont = new SSCFonts.SSCFont(new SSCFonts.SSCFontCharacterSheet());
|
|
this.guns = new SSCGuns.SSCGunManager();
|
|
}
|
|
|
|
public SSCPlayer getPlayer(SSCEnums.PlayerID id)
|
|
{
|
|
if (this.players.ContainsKey(id))
|
|
{
|
|
return this.players[id];
|
|
}
|
|
else return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads in all of the necessary textures for Seaside Scramble.
|
|
/// </summary>
|
|
private void LoadTextures()
|
|
{
|
|
this.textureUtils = new SSCTextureUtilities();
|
|
TextureManager playerManager = new TextureManager("SSCPlayer");
|
|
playerManager.searchForTextures(ModCore.ModHelper, ModCore.Manifest, Path.Combine("Content", "Minigames", "SeasideScramble", "Graphics", "Player"));
|
|
TextureManager mapTextureManager = new TextureManager("SSCMaps");
|
|
mapTextureManager.searchForTextures(ModCore.ModHelper, ModCore.Manifest, Path.Combine("Content", "Minigames", "SeasideScramble", "Maps", "Backgrounds"));
|
|
TextureManager UIManager = new TextureManager("SSCUI");
|
|
UIManager.searchForTextures(ModCore.ModHelper, ModCore.Manifest, Path.Combine("Content", "Minigames", "SeasideScramble", "Graphics", "UI"));
|
|
TextureManager projectileManager = new TextureManager("Projectiles");
|
|
projectileManager.searchForTextures(ModCore.ModHelper, ModCore.Manifest, Path.Combine("Content", "Minigames", "SeasideScramble", "Graphics", "Projectiles"));
|
|
TextureManager gunManager = new TextureManager("Guns");
|
|
gunManager.searchForTextures(ModCore.ModHelper, ModCore.Manifest, Path.Combine("Content", "Minigames", "SeasideScramble", "Graphics", "Guns"));
|
|
TextureManager enemies = new TextureManager("Enemies");
|
|
enemies.searchForTextures(ModCore.ModHelper, ModCore.Manifest, Path.Combine("Content", "Minigames", "SeasideScramble", "Graphics", "Enemies"));
|
|
|
|
this.textureUtils.addTextureManager(playerManager);
|
|
this.textureUtils.addTextureManager(mapTextureManager);
|
|
this.textureUtils.addTextureManager(UIManager);
|
|
this.textureUtils.addTextureManager(projectileManager);
|
|
this.textureUtils.addTextureManager(gunManager);
|
|
this.textureUtils.addTextureManager(enemies);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads in all of the maps for Seaside Scramble.
|
|
/// </summary>
|
|
private void LoadMaps()
|
|
{
|
|
this.SeasideScrambleMaps = new Dictionary<string, SeasideScrambleMap>();
|
|
this.SeasideScrambleMaps.Add("TestRoom", new SeasideScrambleMap(SeasideScrambleMap.LoadMap("TestRoom.tbin").Value));
|
|
this.SeasideScrambleMaps.Add("ShootingGallery", new SSCMaps.ShootingGallery(SeasideScrambleMap.LoadMap("ShootingGallery.tbin").Value));
|
|
}
|
|
/// <summary>
|
|
/// Loads in a default map for Seaside Scramble.
|
|
/// </summary>
|
|
private void loadStartingMap()
|
|
{
|
|
this.currentMap = this.SeasideScrambleMaps["ShootingGallery"];
|
|
}
|
|
|
|
/// <summary>
|
|
/// What happens when the screen changes size.
|
|
/// </summary>
|
|
public void changeScreenSize()
|
|
{
|
|
Viewport viewport = StardewValley.Game1.graphics.GraphicsDevice.Viewport;
|
|
double num1 = (double)(viewport.Width / 2 - 384);
|
|
viewport = StardewValley.Game1.graphics.GraphicsDevice.Viewport;
|
|
double num2 = (double)(viewport.Height / 2 - 384);
|
|
this.topLeftScreenCoordinate = new Vector2((float)num1, (float)num2);
|
|
this.camera.viewport = new xTile.Dimensions.Rectangle(StardewValley.Game1.viewport);
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used to update Stardew Valley while this minigame runs. True means SDV updates false means the SDV pauses all update ticks.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool doMainGameUpdates()
|
|
{
|
|
return false;
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draws all game aspects to the screen.
|
|
/// </summary>
|
|
/// <param name="b"></param>
|
|
public void draw(SpriteBatch b)
|
|
{
|
|
|
|
if (this.currentMap != null)
|
|
{
|
|
this.currentMap.draw(b);
|
|
}
|
|
|
|
b.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
|
|
|
|
foreach(SSCPlayer p in this.players.Values) {
|
|
p.draw(b);
|
|
|
|
}
|
|
|
|
/*
|
|
if (this.menuManager.activeMenu != null)
|
|
{
|
|
this.menuManager.activeMenu.draw(b);
|
|
}
|
|
*/
|
|
foreach (SSCPlayer p in this.players.Values)
|
|
{
|
|
p.drawHUD(b);
|
|
if (p.playerID == SSCEnums.PlayerID.One)
|
|
{
|
|
p.drawMouse(b);
|
|
}
|
|
}
|
|
this.entities.draw(b);
|
|
|
|
this.menuManager.drawAll(b);
|
|
|
|
b.End();
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// The id of the minigame???
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string minigameId()
|
|
{
|
|
return "Seaside Scramble Stardew Lite Edition";
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the game mode for the game.
|
|
/// </summary>
|
|
/// <param name="Mode"></param>
|
|
public void setMode(SSCEnums.SSCGameMode Mode)
|
|
{
|
|
if (Mode == SSCEnums.SSCGameMode.None)
|
|
{
|
|
this.friendlyFireEnabled = false;
|
|
}
|
|
if(Mode== SSCEnums.SSCGameMode.ShootingGallery)
|
|
{
|
|
this.friendlyFireEnabled = true;
|
|
}
|
|
|
|
if(Mode== SSCEnums.SSCGameMode.PVP)
|
|
{
|
|
this.friendlyFireEnabled = true;
|
|
}
|
|
if(Mode== SSCEnums.SSCGameMode.Story)
|
|
{
|
|
this.friendlyFireEnabled = false;
|
|
}
|
|
|
|
this.gameMode = Mode;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~//
|
|
// Input Logic //
|
|
//~~~~~~~~~~~~~~~~~//
|
|
#region
|
|
|
|
/// <summary>
|
|
/// What happens when the left click is held.
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
public void leftClickHeld(int x, int y)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does this override free mous emovements?
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool overrideFreeMouseMovement()
|
|
{
|
|
return true;
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// ??? Undocumended.
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
public void receiveEventPoke(int data)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// What happens when a key is pressed.
|
|
/// </summary>
|
|
/// <param name="k"></param>
|
|
public void receiveKeyPress(Keys k)
|
|
{
|
|
//throw new NotImplementedException();
|
|
if (k == Keys.Escape)
|
|
{
|
|
this.quitGame = true;
|
|
}
|
|
|
|
foreach(SSCPlayer player in this.players.Values)
|
|
{
|
|
player.receiveKeyPress(k);
|
|
}
|
|
|
|
if (this.menuManager.isMenuUp)
|
|
{
|
|
this.menuManager.activeMenu.receiveKeyPress(k);
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a gamepad state.
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public GamePadState getGamepadState(PlayerIndex index)
|
|
{
|
|
return Microsoft.Xna.Framework.Input.GamePad.GetState(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the minigame registeres a key on the keyboard being released.
|
|
/// </summary>
|
|
/// <param name="K"></param>
|
|
public void receiveKeyRelease(Keys K)
|
|
{
|
|
foreach (SSCPlayer player in this.players.Values)
|
|
{
|
|
player.receiveKeyRelease(K);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the minigame receives a left click.
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
/// <param name="playSound"></param>
|
|
public void receiveLeftClick(int x, int y, bool playSound = true)
|
|
{
|
|
if (this.menuManager.activeMenu != null)
|
|
{
|
|
this.menuManager.activeMenu.receiveLeftClick(x, y, playSound);
|
|
}
|
|
foreach(SSCPlayer player in this.players.Values)
|
|
{
|
|
player.receiveLeftClick(x, y);
|
|
}
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the minigame receives a right click.
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
/// <param name="playSound"></param>
|
|
public void receiveRightClick(int x, int y, bool playSound = true)
|
|
{
|
|
if (this.menuManager.activeMenu != null)
|
|
{
|
|
this.menuManager.activeMenu.receiveRightClick(x, y, playSound);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// What happens when left click is released.
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
public void releaseLeftClick(int x, int y)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// What happens when right click is released.
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
public void releaseRightClick(int x, int y)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Receive input from a specific gamepad.
|
|
/// </summary>
|
|
/// <param name="state"></param>
|
|
/// <param name="ID"></param>
|
|
private void receiveGamepadInput(GamePadState state,SSCEnums.PlayerID ID)
|
|
{
|
|
if (state == null) return;
|
|
else
|
|
{
|
|
if (this.players.ContainsKey(ID))
|
|
{
|
|
this.players[ID].receiveGamepadInput(state);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the delta for mouse movement.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Vector2 getMouseDelta()
|
|
{
|
|
Vector2 ret = -1 * (this.oldMousePosition - new Vector2(Game1.getMousePosition().X, Game1.getMousePosition().Y));
|
|
return ret;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Called every update frame.
|
|
/// </summary>
|
|
/// <param name="time"></param>
|
|
/// <returns></returns>
|
|
public bool tick(GameTime time)
|
|
{
|
|
KeyboardState kState = Keyboard.GetState();
|
|
|
|
foreach (Keys k in kState.GetPressedKeys())
|
|
{
|
|
this.receiveKeyPress(k);
|
|
}
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
GamePadState state = this.getGamepadState((PlayerIndex)i);
|
|
this.receiveGamepadInput(state,(SSCEnums.PlayerID)i);
|
|
}
|
|
|
|
|
|
|
|
if (this.quitGame)
|
|
{
|
|
return true;
|
|
}
|
|
if (this.currentMap != null)
|
|
{
|
|
this.currentMap.update(time);
|
|
}
|
|
|
|
|
|
if (this.menuManager.activeMenu != null)
|
|
{
|
|
this.menuManager.activeMenu.update(time);
|
|
if (this.menuManager.activeMenu.readyToClose())
|
|
{
|
|
this.menuManager.closeActiveMenu();
|
|
}
|
|
foreach (SSCPlayer player in this.players.Values)
|
|
{
|
|
player.update(time);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (SSCPlayer player in this.players.Values)
|
|
{
|
|
if (player.playerID == SSCEnums.PlayerID.One) this.camera.centerOnPosition(player.position);
|
|
player.update(time);
|
|
}
|
|
this.entities.update(time);
|
|
}
|
|
|
|
|
|
|
|
this.oldMousePosition = new Vector2(Game1.getOldMouseX(), Game1.getOldMouseY());
|
|
return false;
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the minigame is quit upon.
|
|
/// </summary>
|
|
public void unload()
|
|
{
|
|
//throw new NotImplementedException();
|
|
ModCore.log("Exit the game!");
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~//
|
|
// Static Functions //
|
|
//~~~~~~~~~~~~~~~~~~~~//
|
|
|
|
#region
|
|
|
|
/// <summary>
|
|
/// Translates the position passed in into the relative position on the viewport.
|
|
/// </summary>
|
|
/// <param name="viewport"></param>
|
|
/// <param name="globalPosition"></param>
|
|
/// <returns></returns>
|
|
public static Vector2 GlobalToLocal(xTile.Dimensions.Rectangle viewport, Vector2 globalPosition)
|
|
{
|
|
return new Vector2(globalPosition.X - (float)viewport.X, globalPosition.Y - (float)viewport.Y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Translates the position passed in into the relative position on the viewport.
|
|
/// </summary>
|
|
/// <param name="globalPosition"></param>
|
|
/// <returns></returns>
|
|
public static Vector2 GlobalToLocal(Vector2 globalPosition)
|
|
{
|
|
return new Vector2(globalPosition.X - (float)SeasideScramble.self.camera.viewport.X, globalPosition.Y - (float)SeasideScramble.self.camera.viewport.Y);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|