public async Task SyncTimeline(PlexTrack track, PlayingState state)
{
var parts = track.MetadataUrl.Split('/');
var xml = await connection.RequestXml("/:/timeline", new NameValueCollection()
{
{ "ratingKey", parts[parts.Length - 1] },
{ "key", track.MetadataUrl },
{ "state", new Func <string>(() =>
{
switch (state)
{
case PlayingState.Playing:
return("playing");
case PlayingState.Paused:
return("paused");
case PlayingState.Stopped:
return("stopped");
default:
return(null);
}
}
)() },
{ "hasMDE", "1" },
{ "X-Plex-Session-Identifier", connection.DeviceInfo.ClientIdentifier }
}, "POST");
}
private void WhenPlay()
{
__InternalPlayable.Play();
__State = PlayingState.Playing;
OnPlayingStateChanged();
__PlaybackTimer.Start();
}
void Initialize()
{
Debug.Log("Dirac Initialize");
if (AudioSettings.outputSampleRate != 44100)
{
Debug.LogError("DiracLE pitch shifting only works at 44100 kHz. Use the InitScene to force 44.1 kHz output on iOS.");
this.enabled = false;
return;
}
int numBuffers;
AudioSettings.GetDSPBufferSize(out _bufferSize, out numBuffers);
AllocateNativeResources(_bufferSize);
_initialized = true;
_source = gameObject.GetComponent <AudioSource>();
if (_source != null)
{
if (_source.playOnAwake == true && _source.clip != null)
{
_playingState = PlayingState.Playing;
_doProcess = true;
_buffersNeedReset = true;
}
}
if (alwaysProcess)
{
_doProcess = true;
}
}
/// <summary>
/// </summary>
/// <param name="playlistService">The playlist service.</param>
/// <param name="player">The player.</param>
/// <param name="publicTransport">The public transport.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="hotkeyService">The hotkey service.</param>
public NonManagingPlayerService(IPlaylistService playlistService,
IAudioPlayer player,
IPublicTransport publicTransport,
IConfigurationManager configurationManager,
IGlobalHotkeyService hotkeyService)
{
state = PlayingState.Stopped;
this.playlistService = Guard.IsNull(() => playlistService);
this.player = Guard.IsNull(() => player);
this.publicTransport = Guard.IsNull(() => publicTransport);
this.configurationManager = Guard.IsNull(() => configurationManager);
this.hotkeyService = Guard.IsNull(() => hotkeyService);
Subscribe();
prebufferSongs = configurationManager.GetValue("PrebufferSongs", 2, "PlayerService");
PlayNextThreshold = configurationManager.GetValue("PlayNextThreshnoldMs", 500d, "PlayerService");
TrackInterchangeCrossfadeTime = configurationManager.GetValue("TrackInterchangeCrossfadeTimeMs", 500d, "PlayerService");
TrackInterchangeCrossFadeSteps = configurationManager.GetValue("TrackInterchangeCrossfadeSteps", 50, "PlayerService");
maxBackStack = configurationManager.GetValue("MaxBackStack", 2000, "PlayerService");
LastPlayed = configurationManager.GetValue("PlayerService.LastPlayed", Guid.Empty, KnownConfigSections.Hidden);
LastPlayedOffset = configurationManager.GetValue("PlayerService.LastPlayedOffset", 0d, KnownConfigSections.Hidden);
VolumeValue = configurationManager.GetValue("PlayerService.Volume", 1f, KnownConfigSections.Hidden);
preBuffered = new List <TrackContainer>(prebufferSongs.Value);
backStack = new List <TrackContainer>(maxBackStack.Value);
VolumeValue.ValueChanged += VolumeValueOnValueChanged;
RegisterHotkeys();
LoadLastPlayed();
UpdateState();
SendProgress();
}
private void WhenPause()
{
__InternalPlayable.Pause();
__State = PlayingState.Paused;
OnPlayingStateChanged();
__PlaybackTimer.Stop();
}
private void WhenPlay()
{
__InternalPlayable.Play();
__State = PlayingState.Playing;
OnPlayingStateChanged();
__PlaybackTimer.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="ComponentBase" /> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="playlistService">The playlist service.</param>
/// <param name="player">The player.</param>
/// <param name="publicTransport">The public transport.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="hotkeyService">The hotkey service.</param>
public NonManagingPlayerService(ILogger logger,
IPlaylistService playlistService,
IAudioPlayer player,
IPublicTransport publicTransport,
IConfigurationManager configurationManager,
IGlobalHotkeyService hotkeyService)
: base(logger)
{
playlistService.Guard("playlistService");
player.Guard("player");
publicTransport.Guard("publicTransport");
configurationManager.Guard("configurationManager");
state = PlayingState.Stopped;
this.playlistService = playlistService;
this.player = player;
this.publicTransport = publicTransport;
this.configurationManager = configurationManager;
this.hotkeyService = hotkeyService;
publicTransport.ApplicationEventBus.Subscribe <PlaylistUpdatedEvent>(OnPlaylistUpdated);
publicTransport.ApplicationEventBus.Subscribe <ShuffleChangedEvent>(OnShuffleChanged);
prebufferSongs = configurationManager.GetValue("PlayerService.PrebufferSongs", 2);
PlayNextThreshold = configurationManager.GetValue("PlayerService.PlayNextThreshnoldMs", 500d);
TrackInterchangeCrossfadeTime = configurationManager.GetValue("PlayerService.TrackInterchangeCrossfadeTimeMs", 500d);
TrackInterchangeCrossFadeSteps = configurationManager.GetValue("PlayerService.TrackInterchangeCrossfadeSteps", 50);
maxBackStack = configurationManager.GetValue("PlayerService.MaxBackStack", 2000);
preBuffered = new List <TrackContainer>(prebufferSongs.Value);
backStack = new List <TrackContainer>(maxBackStack.Value);
RegisterHotkeys();
}
private void WhenStop()
{
__PlaybackTimer.Stop();
__State = PlayingState.Stopped;
OnPlayingStateChanged();
OnSecondsPlayedChanged();
}
IEnumerator PlayFadeInCoroutine()
{
if (fadeInDelay > 0)
{
yield return(new WaitForSeconds(fadeInDelay));
}
if (isPlaying)
{
yield break;
}
nowState = PlayingState.FadeIn;
isPlaying = true;
while (progress < 1.0f)
{
progress += Time.deltaTime / fadeInTime;
yield return(null);
}
isPlaying = false;
nowState = PlayingState.Stop;
progress = 1.0f;
if (onFinishFadeIn != null)
{
onFinishFadeIn.Invoke();
}
FinishInChange();
}
public void Initialize()
{
lock (SourceLock)
{
if (_state != PlayingState.NONE)
{
// Already initialized
return;
}
var method = RtspRequest.RtspMethod.OPTIONS;
var builder = RtspRequest.CreateBuilder().Uri(_currentUri).Method(method);
// TODO(frank.lamar): Add check for supported operations. Otherwise this call
// is meaning less.
CheckResponse(_client.Send(builder.Build()), method);
// Send Describe to server
method = RtspRequest.RtspMethod.DESCRIBE;
var response = CheckResponse(_client.Send(builder.Method(method).Build()), method);
_tracks = MediaTracks.FromSdp(response.GetBodyAsSdp(), _currentUri, _filter);
// Initialize our session refresh timmer.
_sessionRefreshTimer = new Timer();
_sessionRefreshTimer.AutoReset = true;
_sessionRefreshTimer.Elapsed += SessionRefreshTimer_Elapsed;
_state = PlayingState.INITIALIZED;
}
}
private bool CheckPaused()
{
// ポーズ無効な状態判定
if (stateMachine == null)
{
return(false);
}
PlayingState state = stateMachine.CurrentState;
if ((state == PlayingState.Initialize) ||
(state == PlayingState.Ready) ||
(state == PlayingState.GameOver) ||
(state == PlayingState.AskContinue))
{
return(false);
}
if (BattleManager.Instance?.IsPaused == true)
{
return(true);
}
else if (CheckTriggeredKey(KeyIndex.Start))
{
// ポーズ入力チェック
BattleManager.Instance?.RequestPause();
}
return(false);
}
public LevelFinishedState()
{
playingState = GameEnvironment.GameStateManager.GetGameState("playingState") as PlayingState;
SpriteGameObject overlay = new SpriteGameObject("Sprites/Starbackground");
star1 = new SpriteGameObject("Sprites/Star");
star2 = new SpriteGameObject("Sprites/Star");
star3 = new SpriteGameObject("Sprites/Star");
overlay.Position = new Vector2(GameEnvironment.Screen.X, GameEnvironment.Screen.Y) / 2 - overlay.Center;
star1.Position = overlay.Position + new Vector2(star1.Width / 2, star1.Height / 5);
star3.Position = overlay.Position + new Vector2(star2.Width * 3, star1.Height / 5);
star2.Position = overlay.Position + new Vector2(overlay.Width / 2 - 50, star1.Height / 5);
this.Add(overlay);
this.Add(star1);
this.Add(star2);
this.Add(star3);
star2.Visible = false;
star3.Visible = false;
quitButton = new Button("Sprites/spr_button_quit", 100);
quitButton.Position = new Vector2(GameEnvironment.Screen.X - quitButton.Width - 10, 10);
this.Add(quitButton);
nextButton = new Button("Sprites/spr_button_next", 100);
nextButton.Position = new Vector2(GameEnvironment.Screen.X - quitButton.Width - 10, 130);
this.Add(nextButton);
}
IEnumerator PlayFadeOutCoroutine()
{
if (fadeOutDelay > 0)
{
yield return(new WaitForSeconds(fadeOutDelay));
}
if (isPlaying)
{
yield break;
}
nowState = PlayingState.FadeOut;
isPlaying = true;
if (onStartFadeOut != null)
{
onStartFadeOut.Invoke();
}
while (progress < 1.0f)
{
progress += Time.deltaTime / fadeOutTime;
yield return(null);
}
isPlaying = false;
nowState = PlayingState.Stop;
progress = 1.0f;
FinishOutChange();
}
public Vcr()
{
StoppedState = new StoppedState(this);
PlayingState = new PlayingState(this);
RecordingState = new RecordingState(this);
State = StoppedState;
}
// Use this for initialization
void Start()
{
MicroGameState = PlayingState.Starting;
//DontDestroyOnLoad(this);
seconds = timeLimit;
//StartCoroutine(CountDown());
}
public Player(TechCraftGame game, PlayingState state, World world, Vector3 startPosition)
{
_game = game;
_world = world;
_position = startPosition;
_state = state;
}
public HostLobbyState()
{
//Initialize playingState
playingState = GameWorld.GameStateManager.GetGameState("playing") as PlayingState;
this.Add(new MenuCursor());
//Background
background = new SpriteGameObject("menuBackground");
this.Add(background);
//Make buttons
//New Game
createAsHumanity = new Button("button", "buttonFont", "font", 0, "Humanity", 0);
createAsHumanity.Position = new Vector2(300, 150);
this.Add(createAsHumanity);
createAsNature = new Button("button", "buttonFont", "font", 0, "Nature", 0);
createAsNature.Position = new Vector2(300, 280);
this.Add(createAsNature);
//Options
exitGame = new Button("button", "buttonFont", "font", 0, "Exit", 0);
exitGame.Position = new Vector2(300, 410);
this.Add(exitGame);
}
private IEnumerator audioFadeOut(float fadeTime)
{
while (state == PlayingState.FadeIn || state == PlayingState.FadeOut)
{
yield return(null);
}
if (fadeTime > 0)
{
state = PlayingState.FadeOut;
float timer = fadeTime;
float startVolume = audioSource.volume;
while (audioSource.volume > 0)
{
audioSource.volume = startVolume * timer / fadeTime;
timer -= Time.deltaTime;
if (timer < 0)
{
timer = 0;
}
yield return(null);
}
audioSource.volume = startVolume;
}
lastPlayingTrackTime = audioSource.time;
audioSource.Stop();
state = PlayingState.NotPlaying;
}
public Vcr()
{
StoppedState = new StoppedState(this);
PlayingState = new PlayingState(this);
RecordingState = new RecordingState(this);
State = StoppedState;
}
public void JumpFrames(int framesToJump)
{
if (this._playingState == PlayingState.NoRender)
{
return;
}
this._time = this._render.JumpFrames(framesToJump);
switch (this._playingState)
{
case PlayingState.Finished:
if (this._render.CurrentFrame != this._render.MaxFrame)
{
this._playingState = PlayingState.Paused;
}
break;
case PlayingState.Playing:
break;
case PlayingState.Paused:
if (this._render.CurrentFrame == this._render.MaxFrame)
{
this._playingState = PlayingState.Finished;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
this.UpdateVisuals();
}
private IEnumerator audioFadeIn(float fadeTime, AudioClip musicClip, bool loop, float startPlayTime)
{
while (state == PlayingState.FadeIn || state == PlayingState.FadeOut)
{
yield return(null);
}
audioSource.clip = musicClip;
audioSource.time = startPlayTime;
audioSource.loop = loop;
lastLoopStatus = loop;
lastPlayingTrack = musicClip;
if (fadeTime > 0)
{
state = PlayingState.FadeIn;
float timer = 0f;
audioSource.volume = 0f;
audioSource.Play();
while (audioSource.volume < maxVolume)
{
audioSource.volume = maxVolume * timer / fadeTime;
timer += Time.deltaTime;
yield return(null);
}
}
else
{
audioSource.Play();
}
state = PlayingState.Playing;
audioSource.volume = maxVolume;
}
public void TogglePlaying()
{
switch (this._playingState)
{
case PlayingState.Finished:
this._playingState = PlayingState.Playing;
this._time = 0;
this.UpdatePlaybackRow();
break;
case PlayingState.NoRender:
break;
case PlayingState.Paused:
this._playingState = PlayingState.Playing;
this.UpdatePlaybackRow();
break;
case PlayingState.Playing:
this._playingState = PlayingState.Paused;
this.UpdatePlaybackRow();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
static void Main(string[] args)
{
FieldInfo assetManagerField = typeof(GameEnvironment).GetField("assetManager", BindingFlags.Static | BindingFlags.NonPublic);
assetManagerField.SetValue(null, new EmptyAssetManager());
LocalServer server = new LocalServer();
RemoteClient rc = new RemoteClient(server);
//JoinServerEvent jse = new JoinServerEvent();
//jse.clientName = "test";
LevelUpdatedEvent lue = new LevelUpdatedEvent();
lue.updatedLevel = server.Level;
rc.Send(lue);
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("MyTestFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
Event obj = (Event)formatter.Deserialize(stream);
stream.Close();
startTime = DateTime.UtcNow;
playingState = new PlayingState();
Timer timer = new Timer(tick, null, 0, (int)(1000f / 60f));
Console.Read();
}
/// <summary>
/// React to the input
/// </summary>
/// <param name="inputHelper">The inputhelper to react to input</param>
public override void HandleInput(InputHelper inputHelper)
{
base.HandleInput(inputHelper);
inputHelper.Update();
//Check if the continueButton is being pressed to go back to the game, starting from the last checkpoint
if (continueButton.ButtonIsPressed)
{
game.IsMouseVisible = false;
Mouse.SetPosition(GameEnvironment.Screen.X / 2, GameEnvironment.Screen.Y / 2);
if (File.Exists("Content\\SaveFile.txt"))
{
using (StreamReader stream = new StreamReader("Content\\SaveFile.txt"))
{
string line = stream.ReadLine();
PlayingState playingState = GameEnvironment.GameStateManager.GetGameState("playingState") as PlayingState;
if (line != null)
{
playingState.RoomCounter = int.Parse(line);
}
else
{
playingState.RoomCounter = 0;
}
}
}
GameEnvironment.GameStateManager.SwitchTo("playingState");
bgPosY = 0;
}
//Check if the exitbutton is being pressed, to switch back to the main menu
if (exitButton.ButtonIsPressed)
{
foreach (Sound sound in MusicPlayer.Music)
{
sound.PlaySound();
}
bgPosY = 0;
GameEnvironment.GameStateManager.SwitchTo("titleScreenState");
}
//Change visibility of mouseoverbutton
if (continueButton.IsMouseOver)
{
continueButtonMouseOver.Visible = true;
}
else
{
continueButtonMouseOver.Visible = false;
}
if (exitButtonMouseOver.IsMouseOver)
{
exitButtonMouseOver.Visible = true;
}
else
{
exitButtonMouseOver.Visible = false;
}
}
public static void UpdateAABBPlayerCollision(PlayingState playingState)
{
IEnumerable<Guid> playerEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Player) == ComponentMasks.Player).Select(x => x.ID);
IEnumerable<Guid> levelObjectEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.LevelObjects) == ComponentMasks.LevelObjects).Select(x => x.ID);
//create aa non velocity component for our level objects
VelocityComponent levelObjectVelocityComponent = new VelocityComponent();
levelObjectVelocityComponent.xVelocity = 0f;
levelObjectVelocityComponent.yVelocity = 0f;
foreach (Guid playerid in playerEntities)
{
AABBComponent playerAABBComponent = playingState.AABBComponents[playerid];
VelocityComponent playerVelocityComponent = playingState.VelocityComponents[playerid];
foreach (Guid lobjectid in levelObjectEntities)
{
AABBComponent levelAABBComponent = playingState.AABBComponents[lobjectid];
Manifold manifold = overlapAABB(playerAABBComponent.BoundedBox, playerVelocityComponent, levelAABBComponent.BoundedBox, levelObjectVelocityComponent);
if (manifold.a != null)
{
resolveCollision(playerAABBComponent.BoundedBox, playerVelocityComponent, levelAABBComponent.BoundedBox, levelObjectVelocityComponent, manifold, playingState, playerid);
}
}
}
}
public LevelMenuState()
{
PlayingState playingState = GameEnvironment.GameStateManager.GetGameState("playingState") as PlayingState;
List <Level> levels = playingState.Levels;
// add a background
SpriteGameObject background = new SpriteGameObject("Backgrounds/spr_levelselect", 0, "background");
Add(background);
// add the level buttons
for (int i = 0; i < 12; i++)
{
int row = i / 4;
int column = i % 4;
LevelButton level = new LevelButton(i + 1, levels[i], 1);
level.Position = new Vector2(column * (level.Width + 20), row * (level.Height + 20)) + new Vector2(390, 180);
Add(level);
}
// add a back button
backButton = new Button("Sprites/spr_button_back", 1);
backButton.Position = new Vector2((GameEnvironment.Screen.X - backButton.Width) / 2, 750);
Add(backButton);
}
public static void UpdateEnemyPath(Guid enemyId, PlayingState playingState)
{
AIComponent enemyAIComponent = playingState.AIComponents[enemyId];
//hrmm our current path goal is empty, lets get back to patrolling
if (enemyAIComponent.PathGoal == Vector2.Zero || enemyAIComponent.ActivePath.Count <= 0 || enemyAIComponent.ActiveState.Peek() == AIState.ATTACK)
{
if (enemyAIComponent.ActiveState.Peek() == AIState.PATROL)
{
//set our current path point to our first patrol path point
if (enemyAIComponent.PathGoal == Vector2.Zero)
{
enemyAIComponent.PathGoal = enemyAIComponent.PatrolPath[0];
}
if (enemyAIComponent.ActivePath.Count <= 0)
{
//we have reached our current path goal, update it to the next
//take the current path and move it to the bottom of the list
var currentPathGoal = enemyAIComponent.PatrolPath.First();
enemyAIComponent.PatrolPath.RemoveAt(0);
enemyAIComponent.PatrolPath.Add(currentPathGoal);
enemyAIComponent.PathGoal = enemyAIComponent.PatrolPath[0];
}
playingState.AIComponents[enemyId] = enemyAIComponent;
//set an active path too
SetActivePath(enemyId, playingState);
}
else if (enemyAIComponent.ActiveState.Peek() == AIState.ATTACK)
{
PositionComponent attackPosition = playingState.PositionComponents[enemyAIComponent.EntityToAttack];
Vector2 attackPathGoal = attackPosition.Position;
//we can optimize this method by checking if the attack position has changed at all and ignoring the rest
if (enemyAIComponent.PathGoal == Vector2.Zero || !Vector2.Equals(enemyAIComponent.PathGoal, attackPosition))
{
enemyAIComponent.PathGoal = attackPathGoal;
}
if (enemyAIComponent.ActiveState.Count <= 0)
{
enemyAIComponent.PathGoal = attackPathGoal;
}
if (UpdateTimedEvents)
{
playingState.AIComponents[enemyId] = enemyAIComponent;
//set an active path too
SetActivePath(enemyId, playingState);
}
}
}
}
public void SwitchTo(string name)
{
if (gameStates.ContainsKey(name))
{
currentGameState = gameStates[name];
if (name == "playingState")
{
GameEnvironment.camera.Reset();
PlayingState PS = currentGameState as PlayingState;
PS.setFocus();
}
else if (name == "gameOverState")
{
GameOverState PS = currentGameState as GameOverState;
PS.setFocus();
}
else if (name == "levelFinishedState")
{
LevelFinishedState PS = currentGameState as LevelFinishedState;
PS.setFocus();
}
else
{
GameEnvironment.camera.Reset();
}
}
else
{
throw new KeyNotFoundException("Could not find game state: " + name);
}
}
public override void HandleInput(InputHelper inputHelper)
{
base.HandleInput(inputHelper);
// if the back button is pressed, go back to the title screen
if (backButton.Pressed)
{
ExtendedGame.GameStateManager.SwitchTo(PenguinPairs.StateName_Title);
}
// if a (non-locked) level button has been pressed, go to that level
foreach (LevelButton button in levelButtons)
{
if (button.Pressed && button.Status != LevelStatus.Locked)
{
// go to the playing state
ExtendedGame.GameStateManager.SwitchTo(PenguinPairs.StateName_Playing);
// load the correct level
PlayingState playingState = (PlayingState)ExtendedGame.GameStateManager.GetGameState(PenguinPairs.StateName_Playing);
playingState.LoadLevel(button.LevelIndex);
return;
}
}
}
private void ActivateBuildingState()
{
buildingManager.enabled = true;
inGameUI.DisplayBuildingUI();
currentPlayingState = PlayingState.BUILDING;
}
public void SkipTutorialAndGoToWait() // used to go directly from "tutorial" to wait for ready
{
StopCoroutine("StartCalibrationVoice");
StopCoroutine("StartRumblePractices");
RumblePracticeStart = false;
//AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.VibrationExplain);
//yield return new WaitForSeconds(AudioManager.Instance.VibrationExplain.length);
if (ControllerGUIToRumble != null)
{
ControllerGUIToRumble.SetActive(false);
}
MissionBase m;
foreach (GameObject p in Players)
{
m = p.GetComponent <MissionBase>();
m.StopPracticeRumbleController();
m.StopAllRumble();
}
StartCoroutine(RemoveAnimations());
PlayingState = PlayingState.PraticeMode;
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.PracticeAudio);
}
public void LoadWorld(WorldProvider worldProvider, INetworkProvider networkProvider)
{
PlayingState playState = new PlayingState(this, GraphicsDevice, worldProvider, networkProvider);
LoadingWorldState loadingScreen = new LoadingWorldState();
GameStateManager.AddState("loading", loadingScreen);
GameStateManager.SetActiveState("loading");
worldProvider.Load(loadingScreen.UpdateProgress).ContinueWith(task =>
{
GameStateManager.RemoveState("play");
GameStateManager.AddState("play", playState);
if (networkProvider.IsConnected)
{
GameStateManager.SetActiveState("play");
}
else
{
GameStateManager.RemoveState("play");
worldProvider.Dispose();
}
GameStateManager.RemoveState("loading");
});
}
/// <summary>
/// Plays the given music.
/// </summary>
/// <param name="music">Music.</param>
/// <param name="loop">If set to <c>true</c> loop.</param>
public void PlayMusic(Sound music, bool loop = true)
{
bgmSource.clip = music.clip;
bgmSource.loop = loop;
bgmSource.Play();
musicState = PlayingState.Playing;
}
public static void CheckForEnemy(Guid enemyId, PlayingState playingState, LevelCollisionDetection levelCollisionDetection)
{
AIComponent enemyAIComponent = playingState.AIComponents[enemyId];
//determine if the player is in line of site
IEnumerable<Guid> playerEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Player) == ComponentMasks.Player).Select(x => x.ID);
foreach (Guid playerid in playerEntities)
{
//get the enemy direction
DirectionComponent enemyDirectionComponent = playingState.DirectionComponents[enemyId];
float direction = enemyDirectionComponent.Direction;
if (enemyAIComponent.ActiveState.Peek() != AIState.ATTACK)
{
bool playerSeen = LineOfSiteRayCast.CalculateLineOfSight(playingState.PositionComponents[enemyId].Position, playingState.PositionComponents[playerid].Position, enemyAIComponent.LineOfSight, playingState.DirectionComponents[enemyId].Direction, playingState);
if (playerSeen)
{
//set our path goal
enemyAIComponent.EntityToAttack = playerid;
enemyAIComponent.ActiveState.Push(AIState.ATTACK);
playingState.AIComponents[enemyId] = enemyAIComponent;
UpdateEnemyPath(enemyId, playingState);
AttackEnemy(enemyId, playingState, levelCollisionDetection);
}
}
}
}
/// <summary>
/// Resumes the music.
/// </summary>
public void ResumeMusic()
{
if (musicState == PlayingState.Paused)
{
audioSource.UnPause();
musicState = PlayingState.Playing;
}
}
public static void DrawPlayingStateDisplayEntities(PlayingState playingState, FollowCamera followCamera, SpriteBatch spriteBatch, Texture2D spriteSheet, GraphicsDeviceManager graphicsDevice)
{
IEnumerable<Guid> drawableEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Drawable) == ComponentMasks.Drawable).Select(x => x.ID);
foreach (Guid id in drawableEntities)
{
Rectangle source = playingState.DisplayComponents[id].Source;
Vector2 origin = new Vector2(source.Width / 2, source.Height / 2);
spriteBatch.Draw(spriteSheet, playingState.PositionComponents[id].Position, source, Color.White, playingState.DirectionComponents[id].Direction, origin, 1f, SpriteEffects.None, 0);
}
}
public static void DetectAABBProjectileCollision(PlayingState playingState)
{
IEnumerable<Guid> projectileEntites = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Projectile) == ComponentMasks.Projectile).Select(x => x.ID);
IEnumerable<Guid> playerEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Player) == ComponentMasks.Player).Select(x => x.ID);
IEnumerable<Guid> enemyEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Enemy) == ComponentMasks.Enemy).Select(x => x.ID);
List<Guid> EntitiesToRemove = new List<Guid>();
foreach (Guid projectileid in projectileEntites)
{
PositionComponent projectilePosition = playingState.PositionComponents[projectileid];
//foreach (Guid playerid in playerEntities)
//{
// PositionComponent playerPosition = playingState.PositionComponents[projectileid];
// if (RectCollision(projectilePosition.Destination, playerPosition.Destination))
// {
// HealthComponent playerHealthComponent = playingState.HealthComponents[playerid];
// DamageComponent projectileDamageComponent = playingState.DamageComponents[projectileid];
// playerHealthComponent.Health -= projectileDamageComponent.Damage;
// Console.WriteLine("Player Health: " + playerHealthComponent.Health);
// playingState.HealthComponents[playerid] = playerHealthComponent;
// playingState.DestroyEntity(projectileid);
// }
//}
foreach (Guid enemyid in enemyEntities)
{
PositionComponent enemyPosition = playingState.PositionComponents[enemyid];
AABBComponent aABBComponent = playingState.AABBComponents[enemyid];
if (RectCollision(aABBComponent.BoundedBox, aABBComponent.BoundedBox))
{
HealthComponent enemyHealthComponent = playingState.HealthComponents[enemyid];
DamageComponent projectileDamageComponent = playingState.DamageComponents[projectileid];
enemyHealthComponent.Health -= projectileDamageComponent.Damage;
Console.WriteLine("Enemy Health: " + enemyHealthComponent.Health);
playingState.HealthComponents[enemyid] = enemyHealthComponent;
EntitiesToRemove.Add(projectileid);
}
}
}
foreach (Guid projectileid in EntitiesToRemove)
{
playingState.DestroyEntity(projectileid);
}
}
public static void DrawDebugTiles(PlayingState playingState, SpriteBatch spriteBatch, Texture2D spriteSheet, GraphicsDevice graphicsDevice)
{
Texture2D rect = new Texture2D(graphicsDevice, 80, 30);
Color[] data = new Color[80 * 30];
for (int i = 0; i < data.Length; ++i) data[i] = Color.DarkRed;
rect.SetData(data);
var debugPaths = playingState.DebugComponents.ToList().Select(d => d.Value.Position);
foreach (var path in debugPaths)
{
Rectangle neighborBoundedBox = new Rectangle((int)(path.X), (int)(path.Y), 16, 16);
spriteBatch.Draw(rect, neighborBoundedBox, Color.DarkRed);
}
}
internal Card PlayCard()
{
var context = new PlayingContext(mGame);
var rootState = new PlayingState(context);
var validMoves = rootState.GetValidMoves();
// Exit if only one move is possible.
if (BitwiseCardHelper.GetGroupCount(validMoves) == 1)
return GetRandomCard(validMoves);
bool isCheater = (mGame.Options.DifficultyLevel == GameDifficultyLevel.Cheater);
var bestNode = TreeSearcher.Search(rootState, 100000, !isCheater);
return GetRandomCard(bestNode.Move.Group);
}
public static void DrawEnemyNeighbors(PlayingState playingState, SpriteBatch spriteBatch, Texture2D spriteSheet, GraphicsDevice graphicsDevice)
{
Texture2D rect = new Texture2D(graphicsDevice, 80, 30);
Color[] data = new Color[80 * 30];
for (int i = 0; i < data.Length; ++i) data[i] = Color.Violet;
rect.SetData(data);
IEnumerable<Guid> enemies = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Enemy) == ComponentMasks.Enemy).Select(x => x.ID);
foreach (Guid enemyid in enemies)
{
var position = playingState.PositionComponents[enemyid].Position;
var lineOfSite = playingState.AIComponents[enemyid].LineOfSight;
Rectangle neighborBoundedBox = new Rectangle((int)(position.X - (lineOfSite)), (int)(position.Y - (lineOfSite)), lineOfSite * 2, lineOfSite * 2);
spriteBatch.Draw(rect, neighborBoundedBox, Color.White);
}
}
public static void DrawAABBComponents(PlayingState playingState, SpriteBatch spriteBatch, GraphicsDevice graphicsDevice)
{
Texture2D rect = new Texture2D(graphicsDevice, 80, 30);
Color[] data = new Color[80 * 30];
for (int i = 0; i < data.Length; ++i) data[i] = Color.Chocolate;
rect.SetData(data);
var aabbComponents = playingState.AABBComponents;
foreach (var aabb in aabbComponents)
{
Rectangle destination = aabb.Value.BoundedBox;
spriteBatch.Draw(rect, destination, Color.White);
}
}
public void ResetGame(bool firstTime, bool resetScore)
{
playingState = PlayingState.FirstPlayerTurn;
for (int x = 0; x < 7; x++)
{
for (int y = 0; y < 6; y++)
{
cells[y * 7 + x] = new Cell(x, y, Cell.Type.Empty);
}
}
if (!firstTime)
{
CalculateSizes(new Vector2(0, 0), new Vector2(Game1.G.graphics.PreferredBackBufferWidth,
Game1.G.graphics.PreferredBackBufferHeight));
}
if (resetScore)
{
firstWins = 0; secondWins = 0;
}
}
public static void UpdateProjectiles(PlayingState playingState)
{
//IEnumerable<Guid> projectileEntities = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Projectile) == ComponentMasks.Projectile).Select(x => x.ID).ToList();
//foreach (Guid projectileId in projectileEntities)
//{
// PositionComponent positionComponent = playingState.PositionComponents[projectileId];
// DirectionComponent directionComponent = playingState.DirectionComponents[projectileId];
// VelocityComponent speedComponent = playingState.VelocityComponents[projectileId];
// double vX = speedComponent.xVelocity * Math.Cos(directionComponent.Direction);
// double vY = speedComponent.yVelocity *Math.Sin(directionComponent.Direction);
// Vector2 newPosition = new Vector2(positionComponent.Position.X + (float)vX, positionComponent.Position.Y + (float)vY);
// Rectangle destination = new Rectangle((int)newPosition.X, (int)newPosition.Y, positionComponent.Destination.Width, positionComponent.Destination.Height);
// positionComponent.Position = newPosition;
// positionComponent.Destination = destination;
// playingState.PositionComponents[projectileId] = positionComponent;
//}
}
public static void DrawEnemyActivePath(PlayingState playingState, SpriteBatch spriteBatch, Texture2D spriteSheet, GraphicsDevice graphicsDevice)
{
Texture2D rect = new Texture2D(graphicsDevice, 80, 30);
Color[] data = new Color[80 * 30];
for (int i = 0; i < data.Length; ++i) data[i] = Color.Violet;
rect.SetData(data);
IEnumerable<Guid> enemies = playingState.Entities.Where(x => (x.ComponentFlags & ComponentMasks.Enemy) == ComponentMasks.Enemy).Select(x => x.ID);
foreach (Guid enemyid in enemies)
{
AIComponent aiComponent = playingState.AIComponents[enemyid];
if (aiComponent.ActivePath != null)
{
foreach (var path in aiComponent.ActivePath)
{
Rectangle activePathTile = new Rectangle((int)(path.TilePosition.X), (int)(path.TilePosition.Y), 16, 16);
spriteBatch.Draw(rect, activePathTile, Color.White);
}
}
}
}
private void Awake()
{
// http://clearcutgames.net/home/?p=437
// First we check if there are any other instances conflicting
if (_instance != null && _instance != this)
{
// If that is the case, we destroy other instances
Destroy(gameObject);
}
// Here we save our singleton instance
_instance = this;
// Furthermore we make sure that we don't destroy between scenes (this is optional)
DontDestroyOnLoad(gameObject);
Screen.showCursor = false;
this.PlayingState = PlayingState.TalkingBeforeControllerCalibration;
ReadyNotYetSpawned = false;
readyCounter = -1;
}
void Stabalize()
{
if (_currentAIState == AIStates.PARALYZED)
{
if (Time.time > stablizeTime + stablizeCooldown)
{
stablizeTime = Time.time;
rb.velocity = Vector3.zero;
rb.angularVelocity = Vector3.zero;
_currentAIState = AIStates.DECIDING;
}
}
else if (_currentPlayingState == PlayingState.STUNNED)
{
if (Time.time > playStablizeTime + playStablizeCooldown)
{
playStablizeTime = Time.time;
rb.velocity = Vector3.zero;
rb.angularVelocity = Vector3.zero;
_currentPlayingState = PlayingState.SETTING_UP;
}
}
}
void ResetAIStates()
{
idleTimeLeft = Random.Range(5, 10);
_currentReturningState = ReturningState.NONE;
_currentIdleState = IdleState.NONE;
_currentRoamingState = RoamingState.NONE;
_currentPlayingState = PlayingState.NONE;
}
void Playing()
{
switch (_currentPlayingState)
{
case PlayingState.NONE:
break;
case PlayingState.SETTING_UP:
targetLocation = ExerciseNode.transform.position;
_currentPlayingState = PlayingState.MOVING;
break;
case PlayingState.WAITING:
transform.position = new Vector3(transform.position.x, lastLocation.y + ((float)Math.Sin(Time.time) / floatingStrength), transform.position.z);
break;
case PlayingState.STUNNED:
break;
case PlayingState.MOVING:
transform.position = Vector3.MoveTowards(transform.position, targetLocation,Time.deltaTime / 3);
if (ReachedTarget())
_currentPlayingState = PlayingState.WAITING;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
void CheckParalyze()
{
if (rb.velocity != Vector3.zero && rb.angularVelocity != Vector3.zero)
{
if (_currentAIState == AIStates.PLAYING)
_currentPlayingState = PlayingState.STUNNED;
else
_currentAIState = AIStates.PARALYZED;
}
//_currentAIState = AIStates.IDLING;
}
public void Play()
{
_currentAIState = AIStates.PLAYING;
if (_currentPlayingState == PlayingState.NONE)
_currentPlayingState = PlayingState.SETTING_UP;
}
public void CreateBoundingRects(TmxList<TmxObject> rectangles, PlayingState playingState)
{
foreach (TmxObject rectangle in rectangles)
{
Guid id = playingState.CreateEntity();
playingState.Entities.Where(l => l.ID == id).First().ComponentFlags = ComponentMasks.LevelObjects;
Vector2 position = new Vector2((float)rectangle.X, (float)rectangle.Y);
Rectangle boundedBox = new Rectangle((int)rectangle.X, (int)rectangle.Y, (int)rectangle.Width, (int)rectangle.Height);
playingState.DirectionComponents[id] = new DirectionComponent() { Direction = 0f };
playingState.DisplayComponents[id] = new DisplayComponent() { Source = new Rectangle(342, 108, TileMap.TileSize, TileMap.TileSize) };
playingState.PositionComponents[id] = new PositionComponent() { Position = position };
playingState.AABBComponents[id] = new AABBComponent() { BoundedBox = boundedBox };
playingState.MapObjectComponents[id] = new MapObjectComponent() { Type = MapObjectType.Wall };
}
}
/*public void Pause()
{
if (PlayingState != PlayingState.Paused)
{
lastState = PlayingState;
PlayingState = PlayingState.Paused;
Time.timeScale = 0;
MainLight.enabled = false;
}
else if (PlayingState == PlayingState.Paused)
{
Time.timeScale = 1;
PlayingState = lastState;
MainLight.enabled = true;
}
}*/
IEnumerator StartRumblePractices()
{
if (RumblePracticeStart) // only if not skipped
this.PlayingState = PlayingState.ControllerCalibration;
if (ControllerGUIToRumble != null)
{
ControllerGUIToRumble.SetActive(true);
ControllerGUIToRumble.GetComponent<Animator>().enabled = false;
}
MissionBase m;
for (int i = 0; i < Players.Count; i++)
{
if (RumblePracticeStart) // only if not skipped
{
m = Players[i].GetComponent<MissionBase>();
if (GUIRumbleCounter < 5)
{
//MissionManager.Instance.PracticeControllerRumbleGUI(number-1);
bool showPunchTween = (i == 0); // only player index 0 makes HUD iTween
m.StartPracticeRumbleController(GUIRumbleCounter, showPunchTween);
}
else
{
m.StopPracticeRumbleController();
if (ControllerGUIToRumble.GetComponent<Animator>() != null)
{
if (ControllerGUIToRumble.GetComponent<Animator>().enabled == false)
{
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.VibrationExplain);
yield return new WaitForSeconds(AudioManager.Instance.VibrationExplain.length - 2.5f);
if (ControllerGUIToRumble.GetComponent<Animator>() != null)
ControllerGUIToRumble.GetComponent<Animator>().enabled = true;
}
}
StartCoroutine(RemoveAnimations());
}
}
}
float waitTime = 0;
switch (GUIRumbleCounter)
{
case 0:
case 1:
waitTime = 1;
break;
case 2:
waitTime = 1.8f;
break;
case 3:
waitTime = 2.3f;
break;
default:
waitTime = 2.5f;
break;
}
yield return new WaitForSeconds(waitTime);
MissionManager.Instance.HideControllerGUIs();
yield return new WaitForSeconds(0.5f);
if (GUIRumbleCounter < 5)
{
GUIRumbleCounter++;
if (RumblePracticeStart) // only repeat if this is true
StartCoroutine(StartRumblePractices());
}
else
SkipTutorialAndGoToWait();
}
void Update()
{
if (PlayingState == PlayingState.Playing)
{
TimeLeft -= Time.deltaTime;
if (TimeLeft <= 0 && CurrentRoundJustEnded == false)
{
CurrentRoundJustEnded = true;
PlayingState = PlayingState.DisplayingScore;
MissionManager.Instance.RemoveAllMissions();
GoKitTweenExtensions.shake(Camera.main.transform, 0.5f, new Vector3(0.8f, 0.8f, 0.8f), GoShakeType.Position);
// TODO: who won?
int highestScore = -10000;
int numberOfPeopleWithSameHighScore = 0;
// check highest score
TargetIDColorState winningColor = TargetIDColorState.NotAssigned;
foreach (GameObject g in Players)
{
Player p = g.GetComponent<Player>();
if (p.Points >= highestScore)
{
highestScore = p.Points;
winningColor = g.GetComponent<TargetIDColor>().TargetIDColorState;
}
}
// check if draw
foreach (GameObject g in Players)
{
Player p = g.GetComponent<Player>();
if (p.Points == highestScore)
{
//Debug.Log(p.ToString() + p.Points);
numberOfPeopleWithSameHighScore++;
}
}
if (numberOfPeopleWithSameHighScore > 1) // draw?
winningColor = TargetIDColorState.NotAssigned;
Destroy(GameObject.Find("Music")); // dont play game music when showing score
switch(winningColor)
{
case TargetIDColorState.RedOne:
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.WinRed);
if (DataSaver.Instance != null)
{
foreach (var score in DataSaver.Instance.highScores)
score.RedWins++;
}
//Debug.Log("Red won");
break;
case TargetIDColorState.BlueTwo:
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.WinBlue);
if (DataSaver.Instance != null)
{
foreach (var score in DataSaver.Instance.highScores)
score.BlueWins++;
}
//Debug.Log("blue won");
break;
case TargetIDColorState.GreenThree:
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.WinGreen);
if (DataSaver.Instance != null)
{
foreach (var score in DataSaver.Instance.highScores)
score.GreenWins++;
}
//Debug.Log("green won");
break;
case TargetIDColorState.PinkFour:
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.WinPink);
if (DataSaver.Instance != null)
{
foreach (var score in DataSaver.Instance.highScores)
score.PinkWins++;
}
//Debug.Log("pink won");
break;
case TargetIDColorState.NotAssigned:
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.WinDraw);
//Debug.Log("draw won");
break;
}
Instantiate(Congratulations);
if (DataSaver.Instance != null)
DataSaver.Instance.SaveScoresToDataFile();
}
}
/*if (PlayingState == PlayingState.DisplayingScore)
Camera.GetComponent<GlitchEffect>().enabled = true;
else
Camera.GetComponent<GlitchEffect>().enabled = false;*/
if (Input.GetKeyDown(KeyCode.Escape))
Application.Quit();
if (Input.GetKeyDown(KeyCode.R))
Application.LoadLevel(0);
}
public void ResetLevel()
{
/*if (!musicIsPlaying)
{
Instantiate(MusicPlayer);
musicIsPlaying = true;
}*/
PlayingState = PlayingState.Playing;
if (ControllerGUIToRumble != null)
Destroy(ControllerGUIToRumble);
foreach (ResetObjectPosition r in AllObjectsToReset) // reset all objects to initial state
r.ResetMyPosition();
TimeLeft = TimePerRound;
CurrentRoundJustEnded = false;
CurrentRound--;
if (CurrentRound <= 0)
{
PlayingState = PlayingState.GameIsOver;
return;
}
PlayingState = PlayingState.WaitingForEverbodyToGetReady;
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.NewMissionsFirstTime);
foreach (GameObject p in Players)
p.GetComponent<Player>().Reset();
InvokeRepeating("AllReady", 0, 0.01f);
MissionManager.Instance.GetNewMissions();
//GoKitTweenExtensions.shake(Camera.main.transform, 0.5f, new Vector3(0.2f, 0.2f, 0.2f), GoShakeType.Position);
//if(WaitForReady)
//{
//}
//else
// PlayingState = PlayingState.Playing;
}
protected void EndCheck(Cell cell, bool win)
{
if (cell.type == Cell.Type.FirstPlayer)
{
if (win)
{
playingState = PlayingState.FirstPlayerWin;
firstWins++;
}
else if (!win && cells.All(x => x.type != Cell.Type.Empty))
playingState = PlayingState.DrawGame;
else
playingState = PlayingState.SecondPlayerTurn;
}
else
{
if (win)
{
playingState = PlayingState.SecondPlayerWin;
secondWins++;
}
else if (!win && cells.All(x => x.type != Cell.Type.Empty))
playingState = PlayingState.DrawGame;
else
playingState = PlayingState.FirstPlayerTurn;
}
}
public void CreatePlayerSpawn(TmxList<TmxObject> playerSpawns, PlayingState playingState)
{
foreach (TmxObject playerspawn in playerSpawns)
{
Guid id = playingState.CreateEntity();
playingState.Entities.Where(x => x.ID == id).First().ComponentFlags = ComponentMasks.Player;
playingState.DirectionComponents[id] = new DirectionComponent() { Direction = 0f };
playingState.DisplayComponents[id] = new DisplayComponent() { Source = new Rectangle(451, 470, TileMap.TileSize, TileMap.TileSize) };
playingState.HealthComponents[id] = new HealthComponent() { Health = 100 };
playingState.PositionComponents[id] = new PositionComponent() { Position = new Vector2((float)playerspawn.X, (float)playerspawn.Y) };
playingState.VelocityComponents[id] = new VelocityComponent() { xVelocity = 0f, yVelocity = 0f, xTerminalVelocity = 6f, yTerminalVelocity = 6f };
playingState.AccelerationComponents[id] = new AccelerationComponent() { xAcceleration = 6f, yAcceleration = 6f };
//our origin is going to offset our bounded box
playingState.AABBComponents[id] = new AABBComponent(){ BoundedBox = new Rectangle((int)playerspawn.X - (TileMap.TileSize / 2), (int)playerspawn.Y - (TileMap.TileSize / 2), TileMap.TileSize, TileMap.TileSize)};
}
}
public void CreateEnemySpawns(TmxList<TmxObject> enemySpawns, PlayingState playingState)
{
LevelCollisionDetection levelCollisionDetection = new LevelCollisionDetection(TileMap, TileMap.TileSize);
foreach (TmxObject enemypawn in enemySpawns)
{
Guid id = playingState.CreateEntity();
playingState.Entities.Where(x => x.ID == id).First().ComponentFlags = ComponentMasks.Enemy;
playingState.DirectionComponents[id] = new DirectionComponent() { Direction = (float)(enemypawn.Rotation * (Math.PI / 180)) };
playingState.DisplayComponents[id] = new DisplayComponent() { Source = new Rectangle(343, 470, TileMap.TileSize, TileMap.TileSize) };
playingState.HealthComponents[id] = new HealthComponent() { Health = 15 };
playingState.PositionComponents[id] = new PositionComponent() { Position = new Vector2((float)enemypawn.X + (TileMap.TileSize / 2), (float)enemypawn.Y + (TileMap.TileSize / 2)) };
playingState.VelocityComponents[id] = new VelocityComponent() { xVelocity = 0f, yVelocity = 0f, xTerminalVelocity = 3f, yTerminalVelocity = 3f };
playingState.AccelerationComponents[id] = new AccelerationComponent() { xAcceleration = 3f, yAcceleration = 3f };
playingState.DamageComponents[id] = new DamageComponent()
{
AttackRange = 1 * TileMap.TileSize,
Damage = 5
};
//our origin is going to offset our bounded box
playingState.AABBComponents[id] = new AABBComponent() { BoundedBox = new Rectangle((int)enemypawn.X, (int)enemypawn.Y, TileMap.TileSize, TileMap.TileSize) };
//parse patrol paths
string patrolPaths = enemypawn.Properties["PatrolPath"];
List<Vector2> PatrolVectors = new List<Vector2>();
if (!string.IsNullOrWhiteSpace(patrolPaths))
{
string[] newPaths = patrolPaths.Split('|');
for (int i = 0; i < newPaths.Length; i++)
{
newPaths[i] = newPaths[i].Replace("(", "");
newPaths[i] = newPaths[i].Replace(")", "");
int x = Int32.Parse(newPaths[i].Split(',')[0]);
int y = Int32.Parse(newPaths[i].Split(',')[1]);
//center our points too
x = (x * TileMap.TileSize) + (TileMap.TileSize / 2);
y = (y * TileMap.TileSize) + (TileMap.TileSize / 2);
PatrolVectors.Add(new Vector2(x, y));
}
}
playingState.AIComponents[id] = new AIComponent()
{
ActiveState = new Stack<AIState>(),
LineOfSight = 6 * TileMap.TileSize,
PatrolPath = PatrolVectors,
ActivePath = new LinkedList<Tile>(),
Astar = TileMap.aStar,
AITree = AIPawnSystem.CreatePawnTree(id, playingState, levelCollisionDetection, TileMap.TileSize, TileMap.TileSize)
};
playingState.AIComponents[id].ActiveState.Push(AIState.STILL);
playingState.LabelComponents[id] = new LabelComponent() { Label = "", Position = new Vector2((float)enemypawn.X, (float)(enemypawn.Y - 5)) };
}
}
IEnumerator StartCalibrationVoice()
{
this.PlayingState = PlayingState.TalkingBeforeControllerCalibration;
float length = AudioManager.Instance.CalibrationAudio.length;
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.CalibrationAudio);
yield return new WaitForSeconds(length);
StartCoroutine(StartRumblePractices());
}
// used to go directly from "tutorial" to wait for ready
public void SkipTutorialAndGoToWait()
{
StopCoroutine("StartCalibrationVoice");
StopCoroutine("StartRumblePractices");
RumblePracticeStart = false;
//AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.VibrationExplain);
//yield return new WaitForSeconds(AudioManager.Instance.VibrationExplain.length);
if (ControllerGUIToRumble != null)
ControllerGUIToRumble.SetActive(false);
MissionBase m;
foreach (GameObject p in Players)
{
m = p.GetComponent<MissionBase>();
m.StopPracticeRumbleController();
m.StopAllRumble();
}
StartCoroutine(RemoveAnimations());
PlayingState = PlayingState.PraticeMode;
AudioManager.Instance.PlayAnnouncerVoice(AudioManager.Instance.PracticeAudio);
}
public void ImportTMX(ContentManager content, string filepath, int tilesize, SpriteFont font, PlayingState playingState)
{
TileMap = new TileMap();
var map = new TmxMap(filepath);
TileMap.RowCount = map.Width;
TileMap.ColumnCount = map.Height;
//get and set tile map details
var tileMap = map.Tilesets["Basic"];
CreateTileMap(tileMap);
//get and set level layer
var levelLayer = map.Layers["Level"];
CreateTileArray(levelLayer);
//get and set level bounding rects
var boudingRects = map.ObjectGroups["Level Rects"].Objects;
CreateBoundingRects(boudingRects, playingState);
//get and set player spawn
var playersSpawn = map.ObjectGroups["Player Spawn"].Objects;
CreatePlayerSpawn(playersSpawn, playingState);
//get and set enemy spawns
var enemySpawns = map.ObjectGroups["Enemy Spawns"].Objects;
CreateEnemySpawns(enemySpawns, playingState);
this.Font = font;
}