internal RoomStateChangedEventArgs(RoomState oldState, RoomState newState, DiagnosticsReport report)
{
Debug.Assert(report != null, "report is null");
OldState = oldState;
NewState = newState;
DiagnosticsReport = report;
}
public RoomInfo(NetIncomingMessage msg)
{
roomId = msg.ReadUInt32();
name = msg.ReadString();
usePassword = msg.ReadBoolean();
perPlayerDifficulty = msg.ReadBoolean();
songSelected = msg.ReadBoolean();
msg.SkipPadBits();
roomState = (RoomState)msg.ReadByte();
songSelectionType = (SongSelectionType)msg.ReadByte();
roomHost = new PlayerInfo(msg);
players = msg.ReadInt32();
maxPlayers = msg.ReadInt32();
try
{
if (songSelected)
{
startLevelInfo = new LevelOptionsInfo(msg);
selectedSong = new SongInfo(msg);
}
else
{
startLevelInfo = default;
selectedSong = null;
}
}
catch
{
}
}
public Room(int number, string hotelName, RoomState status, bool allowedSmoking)
{
Number = number;
HotelName = hotelName;
Status = status;
AllowedSmoking = allowedSmoking;
}
private void QuestFailState(RoomState r)
{
myLevel = 5;
dialogueHolderIndex = 5;
isQuestFail = true;
onQuest = false;
}
private Color ColorCode(RoomState state)
{
switch (state)
{
case RoomState.Uninitialized:
return(TextUninitialized);
case RoomState.Initialized:
return(TextReady);
case RoomState.Running:
return(TextRunning);
case RoomState.Aborted:
return(TextAborted);
case RoomState.Completed:
return(TextCompleted);
case RoomState.Error:
return(TextError);
default:
throw new NotImplementedException();
}
}
static void Postfix(CardManager.DiscardCardParams discardCardParams, bool fromNaturalPlay)
{
ProviderManager.TryGetProvider(out SaveManager saveManager);
ProviderManager.TryGetProvider(out RoomManager roomManager);
if (saveManager == null || roomManager == null)
{
return;
}
if (saveManager.PreviewMode)
{
return;
}
RoomState room = roomManager.GetRoom(roomManager.GetSelectedRoom());
List <CharacterState> toProcessCharacters = new List <CharacterState>();
room.AddCharactersToList(toProcessCharacters, Team.Type.Heroes | Team.Type.Monsters);
foreach (CharacterState toProcessCharacter in toProcessCharacters)
{
foreach (IRoomStateModifier roomStateModifier in toProcessCharacter.GetRoomStateModifiers())
{
IRoomStateCardDiscardedAdvancedModifier mod;
if ((mod = roomStateModifier as IRoomStateCardDiscardedAdvancedModifier) != null)
{
mod.OnCardDiscarded(discardCardParams, roomManager.GetSelectedRoom());
}
}
}
}
public RoomState Create()
{
RoomState roomState = new RoomState();
roomState.ID = GuidUtility.GetNewSequentialGuid();
return(roomState);
}
public virtual void StartLevel(PlayerInfo sender, LevelOptionsInfo options, SongInfo song)
{
if (sender.Equals(roomHost))
{
selectedSong = song;
startLevelInfo = options;
SongWithOptions songWithDifficulty = new SongWithOptions(selectedSong, startLevelInfo);
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
outMsg.Write((byte)CommandType.StartLevel);
startLevelInfo.AddToMessage(outMsg);
selectedSong.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered, 0);
BroadcastWebSocket(CommandType.StartLevel, songWithDifficulty);
roomState = RoomState.InGame;
_songStartTime = DateTime.Now;
_readyPlayers.Clear();
}
else
{
Logger.Instance.Warning($"{sender.playerName}({sender.playerId}) tried to start the level, but he is not the host");
}
}
private void OnUpdate(float delta)
{
if (((this.m_Entity != null) && (this.m_Entity.m_Body != null)) && (GameLogic.Release.Game.RoomState == RoomState.Runing))
{
if (this.state == RoomState.Throughing)
{
this.currentTime = -10f;
}
this.state = GameLogic.Release.Game.RoomState;
if ((Updater.AliveTime - this.currentTime) > this.updateTime)
{
Vector3 vector = Utils.World2Screen(this.m_Entity.m_Body.transform.position);
if (((vector.x < 0f) || (vector.x > this.Width)) || ((vector.y < 0f) || (vector.y > this.Height)))
{
if (this.m_Entity.m_Body.GetIsInCamera())
{
this.m_Entity.m_Body.SetIsVislble(false);
}
}
else if (!this.m_Entity.m_Body.GetIsInCamera())
{
this.m_Entity.m_Body.SetIsVislble(true);
}
this.currentTime = Updater.AliveTime;
}
}
}
// Real Room - for game
public Room(Room clone)
{
//Debug.Log ("room clone");
this.myName = clone.myName;
this.myMusic = clone.myMusic;
this.myWidth = clone.myWidth;
this.myHeight = clone.myHeight;
this.bgName = clone.bgName;
this.myFurnitureList = clone.myFurnitureList;
this.myCharacterList = clone.myCharacterList;
this.myTileInteractionList = clone.myTileInteractionList;
this.myMirrorRoom = clone.myMirrorRoom;
this.RoomState = clone.RoomState;
this.mapArea = clone.mapArea;
myGrid = new Grid(myWidth, myHeight);
if (myMirrorRoom != null)
{
myMirrorRoom.shadowGrid = new Grid(myWidth, myHeight);
myMirrorRoom.myShadowMusic = clone.myMirrorRoom.myShadowMusic;
}
CreateRoomInteractables();
}
private IEnumerator UnloadScene()
{
yield return(ContextsWrapper.AssetManager.Clear());
var count = SceneManager.sceneCount;
var sceneList = new List <Scene>();
for (int i = 0; i < count; ++i)
{
var scene = SceneManager.GetSceneAt(i);
sceneList.Add(scene);
}
foreach (var scene in sceneList)
{
if (IsSceneUnloadable(scene))
{
yield return(SceneManager.UnloadSceneAsync(scene.name));
}
}
yield return(Resources.UnloadUnusedAssets());
GC.Collect();
logger.InfoFormat("Server Room is Disposed!");
state = RoomState.Disposed;
}
void InitEffect()
{
mStartObj.SetActive(false);
mReadyObj.SetActive(false);
mTteamObj[0].transform.localPosition = new Vector3(mTteamObj[0].transform.localPosition.x - mXOffset, mTteamObj[0].transform.localPosition.y, mTteamObj[0].transform.localPosition.z);
TweenPosition.Begin(mTteamObj[0], mMoveDuring, new Vector3(mTteamObj[0].transform.localPosition.x + mXOffset, mTteamObj[0].transform.localPosition.y, mTteamObj[0].transform.localPosition.z));
mTteamObj[1].transform.localPosition = new Vector3(mTteamObj[1].transform.localPosition.x + mXOffset, mTteamObj[1].transform.localPosition.y, mTteamObj[1].transform.localPosition.z);
TweenPosition.Begin(mTteamObj[1], mMoveDuring, new Vector3(mTteamObj[1].transform.localPosition.x - mXOffset, mTteamObj[1].transform.localPosition.y, mTteamObj[1].transform.localPosition.z));
UICommon.UICommonMethod.TweenAlphaBegin(mMidObj, 0f, 0f);
mTweenAlpha = UICommon.UICommonMethod.TweenAlphaBegin(mMidObj, mAlphaDuring, 1f);
EventDelegate.Add(mTweenAlpha.onFinished, FinishMove, true);
for (int i = 0; i < mSeatBtnList.Count; i++)
{
mSeatBtnList[i].AddListener(i, BtnEvent);
if (mSeatBtnList.Count < SeatTeam)
{
mSoulObj[i].gameObject.SetActive(false);
}
}
mBtnStart.AddListener((int)GameRoomBtn.STARTBATTLE, BtnEvent);
mBtnQuit.AddListener((int)GameRoomBtn.LEAVEBATTLE, BtnEvent);
mBtnSend.AddListener(SendTalk);
mRoomState = RoomState.StartFlashState;
//UIGuide
IGuideTaskManager.Instance().AddTaskStartListerner((Int32)GameEventEnum.GameEvent_UIGuideRoomBeginBtnStart, StartIGuideTask);
IGuideTaskManager.Instance().SendTaskTrigger((Int32)GameEventEnum.GameEvent_UIGuideTriggerRoomBeginGame);
IGuideTaskManager.Instance().AddTaskStartListerner((Int32)GameEventEnum.GameEvent_UIGuideBackLobbyBtnStart, StartIGuideTask);
IGuideTaskManager.Instance().SendTaskTrigger((Int32)GameEventEnum.GameEvent_UIGuideTriggerBackLobby);
}
// Setter function for the "state" variable
public bool SetState(Position position, RoomState newState)
{
// Defines new value for desired position and calls ChangeTurn()
state[position.Row, position.Column] = newState;
ChangeTurn();
return(true);
}
public override int GetHashCode()
{
int hash = 1;
if (roomInfo_ != null)
{
hash ^= RoomInfo.GetHashCode();
}
hash ^= cards_.GetHashCode();
hash ^= playerInfos_.GetHashCode();
if (RoomState != 0)
{
hash ^= RoomState.GetHashCode();
}
if (WhoseTurn != 0)
{
hash ^= WhoseTurn.GetHashCode();
}
if (LeftCardCount != 0)
{
hash ^= LeftCardCount.GetHashCode();
}
if (LeftTurnTime != 0F)
{
hash ^= LeftTurnTime.GetHashCode();
}
if (LastPlayedCardId != 0)
{
hash ^= LastPlayedCardId.GetHashCode();
}
return(hash);
}
public void UpdatePlayerList(RoomState state)
{
var playersDict = InGameOnlineController.Instance.players;
if (playersDict.Count != players.Count)
{
while (playersDict.Count > players.Count)
{
players.Add(new PlayerListObject(null, this));
}
if (playersDict.Count < players.Count)
{
players.RemoveRange(playersDict.Count, players.Count - playersDict.Count);
}
playersList.tableView.ReloadData();
}
int index = 0;
foreach (var playerPair in playersDict)
{
(players[index] as PlayerListObject).Update(playerPair.Value.playerInfo, state);
index++;
}
}
/// <summary>
/// Distinguish 'Not Placed', 'Redundant'
/// and 'Not Enclosed' rooms.
/// </summary>
RoomState DistinguishRoom(Room room)
{
RoomState res = RoomState.Unknown;
if (room.Area > 0)
{
// Placed if having Area
res = RoomState.Placed;
}
else if (null == room.Location)
{
// No Area and No Location => Unplaced
res = RoomState.NotPlaced;
}
else
{
// must be Redundant or NotEnclosed
SpatialElementBoundaryOptions opt
= new SpatialElementBoundaryOptions();
IList <IList <BoundarySegment> > segs
= room.GetBoundarySegments(opt);
res = (null == segs || segs.Count == 0)
? RoomState.NotEnclosed
: RoomState.Redundant;
}
return(res);
}
public TickStateController Create(ITAlertPhotonClient photonClient)
{
var simulationSummary = new SimulationSummary.SimulationSummary();
// Loading
var loadingState = new LoadingState(new LoadingStateInput());
loadingState.AddTransitions(new OnCompletedTransition(loadingState, LoginState.StateName));
// Login
var loginState = new LoginState();
loginState.AddTransitions(new OnCompletedTransition(loginState, MenuState.StateName));
// Menu
var menuState = new MenuState(photonClient);
// Room
var roomStateInput = new RoomStateInput(photonClient);
var roomState = new RoomState(roomStateInput, photonClient, simulationSummary);
// Test Simulation Summary
var simulationSummaryStateInput = new SimulationSummaryStateInput(simulationSummary);
var simulationSummaryState = new SimulationSummaryState(simulationSummaryStateInput, simulationSummary);
// Add states to controller
var stateController = new TickStateController(loadingState, loginState, menuState, roomState, simulationSummaryState);
stateController.SetParent(ParentStateController);
roomState.SetSubstateParentController(stateController);
menuState.SetSubstateParentController(stateController);
return stateController;
}
//TODO: WIP
public bool LeaveRoom(int playerIndex)
{
if (_state == RoomState.Empty)
{
return(true);
}
bool destroy = false;
for (int i = 0; i < maxPlayers; i++)
{
if (players[i] == playerIndex)
{
players[i] = -1;
Network.Clients[playerIndex].player.LeaveRoom();
if (_state == RoomState.Full)
{
_state = RoomState.Searching;
}
else
{
_state = RoomState.Empty;
destroy = true;
}
}
}
return(destroy);
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.GetComponent <PlayerModule>())
{
roomState = RoomState.activateRoom;
}
}
public Room(int id, int posX, int posY, RoomState roomState)
{
Id = id;
PosX = posX;
PosY = posY;
RoomState = roomState;
}
public void Dispose()
{
#if UNITYSOURCEMODIFIED && !UNITYEDITOR
UnityProfiler.EnableProfiler(false);
#endif
state = RoomState.Disposing;
isDisposed = true;
DisposePlayerConnections();
if (sendSnapshotManager != null)
{
sendSnapshotManager.Dispose();
}
GameModuleManagement.Dispose();
try
{
ResetContexts(true);
sessionStateMachine.ShutDown();
}
catch (Exception e)
{
logger.ErrorFormat("Reset Contexts Error {0}", e);
}
DestoryObjectUnderDefaultGoBattleServer();
ContextsWrapper.CoRoutineManager.StartCoRoutine(UnloadScene());
ContextsWrapper.Dispose();
logger.InfoFormat("Server Room is Disposing...");
}
private RoomState GetRoomState(string roomName)
{
var room = roomRepository.GetByName(roomName);
if (room == null)
{
return(null);
}
var stateFromDb = new RoomState(roomName);
stateFromDb.AddId(room.Id);
var visitors = visitRepository.Get(room.Id);
if (visitors == null || !visitors.Any())
{
return(stateFromDb);
}
visitors.ForEach(visitor =>
{
var userSubscriber = userRepository.GetById(visitor.UserId.Value);
stateFromDb.AddSubscriber(new RoomSubscription {
Subscriber = userSubscriber.Name, LastVisit = visitor.LastVisitTimeStamp.Value
});
});
return(stateFromDb);
}
public virtual async void SetSelectedSongAsync(PlayerInfo sender, SongInfo song)
{
if (sender.Equals(roomHost))
{
selectedSong = song;
NetOutgoingMessage outMsg = HubListener.ListenerServer.CreateMessage();
if (selectedSong == null)
{
switch (roomSettings.SelectionType)
{
case SongSelectionType.Manual:
{
roomState = RoomState.SelectingSong;
outMsg.Write((byte)CommandType.SetSelectedSong);
outMsg.Write((int)0);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
BroadcastWebSocket(CommandType.SetSelectedSong, null);
}
break;
case SongSelectionType.Random:
{
roomState = RoomState.Preparing;
Random rand = new Random();
randomSongTask = BeatSaver.GetRandomSong();
selectedSong = await randomSongTask;
randomSongTask = null;
outMsg.Write((byte)CommandType.SetSelectedSong);
selectedSong.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
BroadcastWebSocket(CommandType.SetSelectedSong, selectedSong);
ReadyStateChanged(roomHost, true);
}
break;
}
}
else
{
roomState = RoomState.Preparing;
outMsg.Write((byte)CommandType.SetSelectedSong);
selectedSong.AddToMessage(outMsg);
BroadcastPacket(outMsg, NetDeliveryMethod.ReliableOrdered);
BroadcastWebSocket(CommandType.SetSelectedSong, selectedSong);
ReadyStateChanged(roomHost, true);
}
}
else
{
Logger.Instance.Warning($"{sender.playerName}:{sender.playerId} tried to select song, but he is not the host");
}
}
// GET: /api/Room?game_name=moshe&player_name=kaki&option=call
public RoomState GET(string gameName, string playerName, string option, string token) //call / fold
{
IRoom r = null;
var ans = new RoomState();
try
{
Server.CheckToken(token);
switch (option)
{
case "fold":
r = Server.GameFacade.Fold(gameName, playerName);
break;
case "call":
r = Server.GameFacade.Call(gameName, playerName);
break;
}
if (r != null)
{
CreateRoomState(playerName, r, ans);
}
return(ans);
}
catch (Exception e)
{
ans.Messege = e.Message;
}
return(ans);
}
void KeyDownEvent()
{
if (Event.current.keyCode == KeyCode.Escape)
{
state = RoomState.Move;
}
}
private void GenerateWall(int x, int y, WallState state, RoomState room, RoomFacing facing, bool isExterior)
{
room.wallStates[facing] = state;
if (state == WallState.None)
{
return;
}
var rotation = facing == RoomFacing.East || facing == RoomFacing.West ? Quaternion.Euler(0, 90, 0) : Quaternion.identity;
var prefab = state == WallState.Solid ? solidWallPrefab : openWallPrefab;
var offset = RoomFacingUtil.GetOffset(facing);
var position = new Vector3(x * unitWorldSize, 0, y * unitWorldSize) + (new Vector3(offset.x, 0, offset.y) * (unitWorldSize / 2));
var wall = GameObject.Instantiate(prefab, position, rotation, startingRoomAnchor.transform);
var blocker = wall.GetComponent <MotorBlocker>();
if (blocker != null)
{
motorController.AddBlocker(blocker);
}
var dimmer = wall.GetComponent <MeshDimmer>();
if (dimmer != null)
{
dimmer.Init(wallDimSpeed, wallDimLevel, room.neverDim || facing == RoomFacing.East || facing == RoomFacing.West || (isExterior && facing == RoomFacing.North));
}
}
private void savecomboboxroomstate(HttpContext context)
{
string liststr = context.Request["list"];
if (string.IsNullOrEmpty(liststr))
{
WebUtil.WriteJson(context, new { status = false, msg = "参数错误" });
return;
}
List <Utility.BasicModel> list = JsonConvert.DeserializeObject <List <Utility.BasicModel> >(liststr);
foreach (var item in list)
{
Foresight.DataAccess.RoomState state = null;
if (item.id > 0)
{
state = Foresight.DataAccess.RoomState.GetRoomState(item.id);
}
if (state == null)
{
state = new RoomState();
}
state.Name = item.value;
state.Save();
}
WebUtil.WriteJson(context, new { status = true });
}
public bool OnEnterRoom(byte roomid)
{
TableError pError = TableManager.Instance.IsCanEnterTable(roomid, false);
if (pError != TableError.TE_Sucess)
{
//进入房间失败了 我们进行处理
/*tagJoinTableEvent pEvent = new tagJoinTableEvent(roomid, pError);
* MsgEventHandle.HandleMsg(pEvent);//无法进入房间的事件*/
UIManager.Instance.ShowMessage(pError.Description(), MessageBoxEnum.Style.Ok, null);
return(false);
}
_curRoomId = roomid;
State = RoomState.HALL_JOIN_ROOM;
//GlobalEffectMgr.Instance.ShowLoadingMessage();
//发送进入房间的命令到服务端去
// CL_Cmd_JoinTable ncb = new CL_Cmd_JoinTable();
// ncb.SetCmdType(NetCmdType.CMD_CL_JoinTable);
// ncb.bTableType = roomid;
// NetManager.Instance.Send<CL_Cmd_JoinTable>(ncb);
// State = RoomState.HALL_JOIN_ROOM;
return(true);
}
void FinishSoulMove()
{
mRoomState = RoomState.StartGameState;
EventDelegate.Remove(mTweenSoulMove.onFinished, FinishSoulMove);
EventCenter.SendEvent(new BlGame.CEvent(EGameEvent.eGameEvent_IntoHero));
}
void OnTriggerEnter2D(Collider2D col)
{
if (col.gameObject.tag == "Player" && myRoomState == RoomState.inactive)
{
Debug.Log("ENTERED ROOM!");
myRoom.placeDoors();
myRoomState = RoomState.active;
gameObject.tag = "ActiveRoom";
//Here is where you would spawn enemies or something. Shouldn't be too bad
/* EnemyManager myEnemyManager = new EnemenyManager();
* myEnemyList = new List<GameObject>();
* for (int i = Random.value *3 + 2; i <= 0; i--) {
* myEnemyList.Add(myEnemyManager.newEnemy())
* }
*/
for (int i = 0; i < Random.Range(1, 4); i++)
{
_orchestrator.SpawnEnemy("imp", transform.position);
}
if (Random.value < 0.5f)
{
_orchestrator.SpawnEnemy("fallen", transform.position);
}
}
}
public bool CanDeleteRoom(RoomState roomState, int roomId, int transferRoomId, DateTime date)
{
if (roomState.Exists && !_historyRepository.RoomDeletedInFuture(roomId, date) &&
_historyRepository.RoomAliveInPast(transferRoomId, date) && _historyRepository.RoomNotCreatedInThisDay(roomId, date))
return true;
throw new InvalidOperationException();
}
//undiscovered || hidden || discovered -> playerInside
//defeatedOutside -> defeatedInside
//boss -> bossBattle
//Is called by a doorway when player collides with it
public void entered()
{
transform.parent.GetComponent<RoomTracker>().resetAll();
//Updates the room status accordingly
if (roomType == RoomState.boss)
roomType = RoomState.bossBattle;
else if (roomType == RoomState.defeatedOutside)
roomType = RoomState.defeatedInside;
else if (roomType == RoomState.undiscovered || roomType == RoomState.hidden || roomType == RoomState.discovered)
roomType = RoomState.playerInside;
transform.parent.GetComponent<RoomTracker>().UpdateMap();
}
public void GetCurrentState()
{
var count = GameControllerLevel2.Instance.HouseTechnology.EconomyProgress * 2;
if (count >= 0.8f)
{
CurrentState = RoomState.Good;
return;
}
if (count >= 0.4f)
{
CurrentState = RoomState.Good;
return;
}
CurrentState = RoomState.Bad;
}
void Update ()
{
timeElapsed.update (Time.deltaTime);
if (actualState == RoomState.LOAD_NEW_LEVEL)
{
//Debug.Log ("wtf\n"); //przy ladowaniu wczesniej wyczyszczonego pokoju wykonuje sie to kilkanascie razy
//przenioslem czesc rzeczy do laodNewRoom
GameObject[] objs = GameObject.FindGameObjectsWithTag("Player");
//Debug.Log ("size: " + objs.GetLength(0));
foreach(GameObject obj in objs){
if(obj.GetComponent<BasicStats>() == null){
Debug.Log ("get component == null");
}
else{
if(obj.GetComponent<BasicStats>().timerInvoulnerable == null){
Debug.Log ("timer invoulnerable == null");
}
}
obj.GetComponent<BasicStats>().timerInvoulnerable.reset();
}
if(roomToLoad.wasCleared){
if (timeElapsed.getTime () > 0.5f) {
actualState = RoomState.ROOM_CLEAR;
}
}
else {
actualState = RoomState.FIGHT;
}
}
else if (actualState == RoomState.FIGHT)
{
if (enemyHolder.transform.childCount == 0)
{
roomToLoad.vecEnemies.Clear();
generateItem();
actualState = RoomState.ROOM_CLEAR;
}
}
else if (actualState == RoomState.ROOM_CLEAR)
{
openTheGates();
}
}
private void WaitForPlayer(double gameTime)
{
if (Players.Count > 0)
{
_logger.AddLogMessage("Room - " + GameRoomId, "Got enough players, start run camera.");
_roomState = RoomState.Run;
}
}
void IGameInformer.InformTimeUp(IList<int> breakers)
{
RoomState = RoomState.GameEnd;
#warning unfinished
GameEnd();
}
//playerInside -> discovered
//defeatedInside -> defeatedOustide
//hidden, undiscovered and boss stay the same
//bossbattle should never be a situation
//called by the Zone to reset all rooms to proper state before updating the map
public void exited()
{
if (roomType == RoomState.defeatedInside)
roomType = RoomState.defeatedOutside;
else if (roomType == RoomState.playerInside)
roomType = RoomState.discovered;
}
protected virtual void InformTurn(Turn turn)
{
if (RoomState != RoomState.GameStarted) RoomState = RoomState.GameStarted;
game.Update(turn);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
this.Exit();
if (generatedPercent >= 100)
{
MouseState cms = Mouse.GetState();
KeyboardState cks = Keyboard.GetState();
GamePadState cgs = GamePad.GetState(PlayerIndex.One);
Vector2 mp2D = Vector2.Clamp(new Vector2(cms.X, cms.Y), Vector2.Zero, new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
Vector3 mousePos = Helper.ProjectMousePosition(mp2D, GraphicsDevice.Viewport, gameCamera.worldMatrix, gameCamera.viewMatrix, gameCamera.projectionMatrix, 0f);
Vector2 virtualJoystick = Vector2.Zero;
if (cks.IsKeyDown(Keys.W) || cks.IsKeyDown(Keys.Up)) virtualJoystick.Y = -1;
if (cks.IsKeyDown(Keys.A) || cks.IsKeyDown(Keys.Left)) virtualJoystick.X = -1;
if (cks.IsKeyDown(Keys.S) || cks.IsKeyDown(Keys.Down)) virtualJoystick.Y = 1;
if (cks.IsKeyDown(Keys.D) || cks.IsKeyDown(Keys.Right)) virtualJoystick.X = 1;
if (virtualJoystick.Length() > 0f) virtualJoystick.Normalize();
if (cgs.ThumbSticks.Left.Length() > 0.1f)
{
virtualJoystick = cgs.ThumbSticks.Left;
virtualJoystick.Y = -virtualJoystick.Y;
}
if(gameHero.introTargetReached) gameHero.Move(virtualJoystick);
if ((cks.IsKeyDown(Keys.Space) && !lks.IsKeyDown(Keys.Space)) || (cgs.Buttons.B == ButtonState.Pressed && lgs.Buttons.B != ButtonState.Pressed)) gameHero.TryPlantBomb(currentRoom);
if (cks.IsKeyDown(Keys.Z) || cks.IsKeyDown(Keys.Enter) || cgs.Buttons.A == ButtonState.Pressed) gameHero.DoAttack();
if (cks.IsKeyDown(Keys.X) || cks.IsKeyDown(Keys.RightShift) || cgs.Buttons.X == ButtonState.Pressed) gameHero.DoDefend(true, virtualJoystick); else gameHero.DoDefend(false, virtualJoystick);
int openCount = 0;
foreach (Door d in Doors) if (d.IsOpen) openCount++;
if (gameHero.introTargetReached)
{
#region ROOM STATE SHIT
switch (roomState)
{
case RoomState.DoorsOpening:
OpenDoors();
if (openCount > 0) roomState = RoomState.DoorsOpen;
doorCountdown = doorCountdownTarget;
break;
case RoomState.DoorsOpen:
if (doorCountdown > 0)
{
doorCountdown -= gameTime.ElapsedGameTime.TotalMilliseconds;
if (doorCountdown <= 0)
{
roomState = RoomState.DoorsClosing;
}
}
break;
case RoomState.DoorsClosing:
foreach (Door d in Doors) d.Close(false);
if (openCount == 0)
{
roomMovesLeft = 3 + Helper.Random.Next(5);
DoRoomShift();
roomState = RoomState.RoomsShifting;
}
break;
case RoomState.RoomsShifting:
foreach (Door d in Doors) d.Close(true);
if (roomShift != null)
{
roomShift.Update(gameTime, gameHero, ref Rooms);
if (roomShift.Complete)
{
if (roomMovesLeft > 0) DoRoomShift();
else roomShift = null;
}
}
if (roomShift == null && roomMovesLeft == 0)
{
roomState = RoomState.DoorsOpening;
}
break;
}
#endregion
}
else
{
if (Vector3.Distance(gameHero.Position, gameHero.IntroTarget) < 5f)
{
exitDoor.Close(false);
}
}
if (gameHero.RoomX == exitRoomX && gameHero.RoomY == exitRoomY)
{
if (exitDoor.IsOpen)
{
particleController.Spawn(exitDoor.ParticlePosition, new Vector3(-0.05f + ((float)Helper.Random.NextDouble() * 0.1f), -0.05f + ((float)Helper.Random.NextDouble() * 0.1f), -0.05f + ((float)Helper.Random.NextDouble() * 0.1f)) + exitDoor.ParticleDir * 0.2f, 2f, Color.White * 0.5f, 1000, false);
}
}
if (roomShift != null)
gameCamera.Update(gameTime, currentRoom.World, roomShift.cameraShake);
else
gameCamera.Update(gameTime, currentRoom.World, Vector3.Zero);
foreach (Room r in Rooms)
if (r.World != null) r.World.Update(gameTime, gameCamera, currentRoom == r);
//currentRoom.World.Update(gameTime, gameCamera);
gameHero.Update(gameTime, gameCamera, currentRoom, Doors, ref Rooms, allRoomsComplete, exitRoomX, exitRoomY, exitDoor);
currentRoom = Rooms[gameHero.RoomX, gameHero.RoomY];
currentRoom.Update(gameTime);
enemyController.Update(gameTime, gameCamera, currentRoom, gameHero, Doors);
particleController.Update(gameTime, gameCamera, currentRoom.World);
pickupController.Update(gameTime, gameCamera, gameHero, currentRoom);
projectileController.Update(gameTime, gameCamera, gameHero, currentRoom);
bombController.Update(gameTime, currentRoom, gameHero);
AudioController.Update(gameTime);
foreach (Door d in Doors) d.Update(gameTime);
drawEffect.View = gameCamera.viewMatrix;
drawEffect.World = gameCamera.worldMatrix;
lms = cms;
lks = cks;
lgs = cgs;
if (gameHero.Dead || gameHero.exitReached)
{
deadTime += gameTime.ElapsedGameTime.TotalMilliseconds;
if (deadTime >= 5000)
{
Reset();
}
if (showCompleteAlpha < 1f) showCompleteAlpha += 0.1f;
AudioController.StopMusic();
}
allRoomsComplete = true;
foreach (Room r in Rooms) if (!r.IsComplete) allRoomsComplete = false;
if (allRoomsComplete && !shownComplete)
{
if (gameHero.RoomX == exitRoomX && gameHero.RoomY == exitRoomY && roomState == RoomState.DoorsOpen) exitDoor.Open(false);
if(showCompleteAlpha<1f) showCompleteAlpha += 0.1f;
showCompleteTime += gameTime.ElapsedGameTime.TotalMilliseconds;
if (showCompleteTime > 5000)
{
shownComplete = true;
}
}
if (shownComplete && showCompleteAlpha > 0f && !gameHero.exitReached) showCompleteAlpha -= 0.1f;
//if (gameHero.exitReached && showCompleteAlpha < 1f) showCompleteAlpha += 0.1f;
//if (gameHero.exitReached)
//{
// dead
//}
}
else
{
titleFrameTime += gameTime.ElapsedGameTime.TotalMilliseconds;
if (titleFrameTime >= 100)
{
titleFrameTime = 0;
titleCurrentFrame++;
if (titleCurrentFrame == 4) titleCurrentFrame = 0;
}
titleScrollPos += Vector2.One;
if (titleScrollPos.X == texTitleBG.Width) titleScrollPos = Vector2.Zero;
}
base.Update(gameTime);
}
public void loadNewRoom(Room room)
{
roomToLoad = room;
timeElapsed.reset ();
timeElapsed.start ();
actualState = RoomState.LOAD_NEW_LEVEL;
//rzeczy z LOAD_NEW_LEVEL które chcemy uruchomic tylko raz
Debug.Log("new level");
clearMissiles();
spawnObjectsFromVectors();
spawnRoomTypeSpecialObjects();
}
void spawnObjectsFromVectors(){
if (roomToLoad == null) {
actualState = RoomState.LOAD_NEW_LEVEL;
return;
}
clearDoors();
clearItems ();
clearDrops ();
roomToLoad.spawnEnemies ();
roomToLoad.spawnDoors (GameObject.Find ("PrefabHolder").GetComponent<PrefabHolder>().testDoors);
buildDrops ();
buildItemsFromRoom (roomToLoad.vecItems);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
generatedPercent = 0;
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
if (firstRun)
{
AudioController.LoadContent(Content);
tileSheet = new VoxelSprite(16, 16, 16);
LoadVoxels.LoadSprite(Path.Combine(Content.RootDirectory, "tiles.vxs"), ref tileSheet);
doorSheet = new VoxelSprite(16, 16, 16);
LoadVoxels.LoadSprite(Path.Combine(Content.RootDirectory, "door.vxs"), ref doorSheet);
objectSheet = new VoxelSprite(16, 16, 16);
LoadVoxels.LoadSprite(Path.Combine(Content.RootDirectory, "dynamic.vxs"), ref objectSheet);
}
else if (AudioController.instances["roomscrape"].State == SoundState.Playing) AudioController.instances["roomscrape"].Pause();
gameCamera = new Camera(GraphicsDevice, GraphicsDevice.Viewport);
particleController = new ParticleController(GraphicsDevice);
projectileController = new ProjectileController(GraphicsDevice);
pickupController = new PickupController(GraphicsDevice);
bombController = new BombController(GraphicsDevice, objectSheet);
enemyController = new EnemyController(GraphicsDevice);
projectileController.LoadContent(Content);
pickupController.LoadContent(Content);
enemyController.LoadContent(Content);
drawEffect = new BasicEffect(GraphicsDevice)
{
World = gameCamera.worldMatrix,
View = gameCamera.viewMatrix,
Projection = gameCamera.projectionMatrix,
VertexColorEnabled = true,
};
gameHero = new Hero(0, 0, Vector3.Zero, Vector3.Zero);
gameHero.LoadContent(Content, GraphicsDevice);
ThreadPool.QueueUserWorkItem(delegate { CreateRoomsAsync(); });
doorCountdown = 10000;
roomMovesLeft = 0;
roomShift = null;
roomState = RoomState.DoorsOpen;
deadTime = 0;
allRoomsComplete = false;
shownComplete = false;
showCompleteTime = 0;
showCompleteAlpha = 0f;
Doors.Clear();
Doors.Add(new Door(VoxelWorld.ToScreenSpace((7 * 16) + 7, 7, 21) + new Vector3(Voxel.HALF_SIZE,Voxel.HALF_SIZE,Voxel.HALF_SIZE), 0, doorSheet));
Doors.Add(new Door(VoxelWorld.ToScreenSpace((14 * 16) + 7, (4 * 16) + 7, 21) + new Vector3(Voxel.HALF_SIZE, Voxel.HALF_SIZE, Voxel.HALF_SIZE), 1, doorSheet));
Doors.Add(new Door(VoxelWorld.ToScreenSpace((7 * 16) + 7, (8 * 16) + 7, 21) + new Vector3(Voxel.HALF_SIZE, Voxel.HALF_SIZE, Voxel.HALF_SIZE), 2, doorSheet));
Doors.Add(new Door(VoxelWorld.ToScreenSpace(7, (4 * 16) + 7, 21) + new Vector3(Voxel.HALF_SIZE, Voxel.HALF_SIZE, Voxel.HALF_SIZE), 3, doorSheet));
if (firstRun)
{
roomIcon = Content.Load<Texture2D>("roomicon");
texHud = Content.Load<Texture2D>("hud");
texTitle = Content.Load<Texture2D>("titlesheet");
texTitleBG = Content.Load<Texture2D>("title-bg");
texStingers = Content.Load<Texture2D>("stingers");
font = Content.Load<SpriteFont>("font");
timerFontLarge = Content.Load<SpriteFont>("timerfont-large");
timerFontSmall = Content.Load<SpriteFont>("timerfont-small");
}
firstRun = false;
}
void IGameInformer.InformGameResult(int[] gameResult, bool isStoped)
{
RoomState = RoomState.GameEnd;
#warning unfinished
GameEnd();
}
