public Scene(GameObjectManager objectManager, ISceneManager sceneManager, SceneType sceneType)
{
this.sceneManager = sceneManager;
this.sceneType = sceneType;
ObjectManager = objectManager;
GameObjectState = objectManager;
}
void HookupApplicationEvents()
{
IInjectionBinder binder = ((MainContext)context).injectionBinder;
IApplicationEvents appEvents = GameApplication.Instance.ApplicationEvents;
appEvents.Paused += () => binder.GetInstance <GamePausedSignal>().Dispatch();
appEvents.Resumed += t => binder.GetInstance <GameResumedSignal>().Dispatch(t);
appEvents.LostFocus += () => binder.GetInstance <FocusLostSignal>().Dispatch();
appEvents.GainedFocus += () => binder.GetInstance <FocusGainedSignal>().Dispatch();
ISceneManager sceneManager = _moduleContainer.ServiceResolver.Get <ISceneManager>();
sceneManager.TransitionOutStarted += s
=> binder.GetInstance <SceneTransitionOutStartedSignal>().Dispatch(s);
sceneManager.TransitionOutEnded += s =>
binder.GetInstance <SceneTransitionOutEndedSignal>().Dispatch(s);
sceneManager.TransitionInStarted += s =>
binder.GetInstance <SceneTransitionInStartedSignal>().Dispatch(s);
sceneManager.TransitionInEnded += s
=> binder.GetInstance <SceneTransitionInEndedSignal>().Dispatch(s);
sceneManager.SceneLoadStarted += s =>
binder.GetInstance <SceneLoadStartedSignal>().Dispatch(s);
sceneManager.SceneLoaded += s =>
binder.GetInstance <SceneLoadedSignal>().Dispatch(s);
}
public ApplicationWindow(ILogger logger, IShaderLoader shaderLoader,
ISceneManager sceneManager) : base(1280, 720, new GraphicsMode(new ColorFormat(8, 8, 8, 8), 0, 0, 8), "")
{
this.logger = logger;
this.shaderLoader = shaderLoader;
this.sceneManager = sceneManager;
}
//Pause Screen is dismissed with Space!
public override void HandleKeys(InputHelper aInputHelper, ISceneManager aSceneManager)
{
if (aInputHelper.IsNewPress(Keys.Space))
{
aSceneManager.HideOverlay();
}
}
public override void Initialize()
{
base.Initialize();
_sceneManager = Game.Services.GetService <ISceneManager>();
_sceneManager.SceneActivated += _sceneManager_SceneActivated;
_spriteBatch = new SpriteBatch(Game.GraphicsDevice);
}
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
public SoundComponent()
{
m_SoundManager = GameFrameworkEntry.GetModule <ISoundManager>();
if (m_SoundManager == null)
{
Log.Fatal("Sound manager is invalid.");
return;
}
m_SoundManager.PlaySoundSuccess += OnPlaySoundSuccess;
m_SoundManager.PlaySoundFailure += OnPlaySoundFailure;
m_SoundManager.PlaySoundUpdate += OnPlaySoundUpdate;
m_SoundManager.PlaySoundDependencyAsset += OnPlaySoundDependencyAsset;
// m_AudioListener = gameObject.GetOrAddComponent<AudioListener>();
m_AudioListener = new GameObject("AudioListener").GetOrAddComponent <AudioListener>();
SceneManager.sceneLoaded += OnSceneLoaded;
SceneManager.sceneUnloaded += OnSceneUnloaded;
ISceneManager sceneManager = GameFrameworkEntry.GetModule <ISceneManager>();
if (sceneManager == null)
{
Log.Fatal("Scene manager is invalid.");
return;
}
sceneManager.LoadSceneSuccess += OnLoadSceneSuccess;
sceneManager.LoadSceneFailure += OnLoadSceneFailure;
sceneManager.UnloadSceneSuccess += OnUnloadSceneSuccess;
sceneManager.UnloadSceneFailure += OnUnloadSceneFailure;
}
private void ProcessMoneyTransferRequest(UUID fromID, UUID toID, int amount, int type, string description)
{
if (toID != UUID.Zero)
{
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null && manager.Scene != null)
{
ISceneChildEntity ent = manager.Scene.GetSceneObjectPart(toID);
if (ent != null)
{
bool success = m_connector.UserCurrencyTransfer(ent.OwnerID, fromID, UUID.Zero, UUID.Zero, (uint)amount, description,
(TransactionType)type, UUID.Random());
if (success)
{
FireObjectPaid(toID, fromID, amount);
}
}
else
{
m_connector.UserCurrencyTransfer(toID, fromID, UUID.Zero, UUID.Zero, (uint)amount, description,
(TransactionType)type, UUID.Random());
}
}
}
}
public object SendAttachments(string funct, object param)
{
object[] parameters = (object[])param;
IScenePresence sp = (IScenePresence)parameters[1];
Interfaces.GridRegion dest = (Interfaces.GridRegion)parameters[0];
ISceneManager manager = sp.Scene.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (var scene in manager.GetAllScenes())
{
if (dest.RegionID == scene.RegionInfo.RegionID)
{
return(null);
}
}
}
if (m_userAttachments.ContainsKey(sp.UUID))
{
Util.FireAndForget(delegate
{
foreach (ISceneEntity attachment in m_userAttachments[sp.UUID])
{
Connectors.Simulation.SimulationServiceConnector ssc = new Connectors.Simulation.SimulationServiceConnector();
attachment.IsDeleted = false;//Fix this, we 'did' get removed from the sim already
//Now send it to them
ssc.CreateObject(dest, (ISceneObject)attachment);
attachment.IsDeleted = true;
}
});
}
return(null);
}
private void NextScene()
{
if (sceneManager != null)
{
sceneManager.Finish -= SceneManager_Finish;
sceneManager.Destroy();
}
if (sceneManager == null)
{
sceneManager = new Scene1Manager();
}
else if (sceneManager is Scene1Manager)
{
sceneManager = new Scene2Manager();
}
else if (sceneManager is Scene2Manager)
{
sceneManager = new Scene3Manager();
}
else
{
Application.Exit();
}
sceneManager.Finish += SceneManager_Finish;
sceneManager.Init();
}
public bool IsAuthorizedForRegion(GridRegion region, AgentCircuitData agent, bool isRootAgent, out string reason)
{
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
#if (!ISWIN)
foreach (IScene scene in manager.GetAllScenes())
{
if (scene.RegionInfo.RegionID == region.RegionID)
{
//Found the region, check permissions
return(scene.Permissions.AllowedIncomingAgent(agent, isRootAgent, out reason));
}
}
#else
foreach (IScene scene in manager.GetAllScenes().Where(scene => scene.RegionInfo.RegionID == region.RegionID))
{
//Found the region, check permissions
return(scene.Permissions.AllowedIncomingAgent(agent, isRootAgent, out reason));
}
#endif
}
reason = "Not Authorized as region does not exist.";
return(false);
}
public LoadingScene(Game game, ISceneManager sceneManager, IGraphicsSystem graphicsSystem, IGameSettings gameSettings, IGameLogger logger, IGameKeys gameKeys) :
base(game, sceneManager, graphicsSystem, gameSettings, logger, gameKeys)
{
IsLoaded = false;
_uiBatch = new SpriteBatch(Game.GraphicsDevice);
}
/// <summary>
/// Region side
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
protected OSDMap OnMessageReceived(OSDMap message)
{
//We need to check and see if this is an AgentStatusChange
if (message.ContainsKey("Method") && message["Method"] == "EstateUpdated")
{
OSDMap innerMessage = (OSDMap)message["Message"];
//We got a message, deal with it
uint estateID = innerMessage["EstateID"].AsUInteger();
UUID regionID = innerMessage["RegionID"].AsUUID();
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
foreach (IScene scene in manager.Scenes)
{
if (scene.RegionInfo.EstateSettings.EstateID == estateID)
{
IEstateConnector estateConnector =
Framework.Utilities.DataManager.RequestPlugin <IEstateConnector>();
if (estateConnector != null)
{
EstateSettings es = null;
if ((es = estateConnector.GetEstateSettings(regionID)) != null && es.EstateID != 0)
{
scene.RegionInfo.EstateSettings = es;
MainConsole.Instance.Debug("[EstateProcessor]: Updated estate information.");
}
}
}
}
}
}
return(null);
}
public GameState(
ISceneManager sceneManager,
IResourceManager resourceManager,
IPaletteProvider paletteProvider,
IEngineDataManager engineDataManager,
IRenderWindow renderWindow,
ISoundProvider soundProvider,
IMPQProvider mpqProvider,
Func <IMapRenderer> getMapEngine,
Func <eSessionType, ISessionManager> getSessionManager,
Func <string, IRandomizedMapGenerator> getRandomizedMapGenerator
)
{
this.sceneManager = sceneManager;
this.resourceManager = resourceManager;
this.paletteProvider = paletteProvider;
this.getMapEngine = getMapEngine;
this.getSessionManager = getSessionManager;
this.engineDataManager = engineDataManager;
this.renderWindow = renderWindow;
this.soundProvider = soundProvider;
this.mpqProvider = mpqProvider;
this.getRandomizedMapGenerator = getRandomizedMapGenerator;
originalMouseCursor = renderWindow.MouseCursor;
PlayerInfos = new List <PlayerInfo>();
mapDataLookup = new List <MapCellInfo>();
}
void ProcessMoneyTransferRequest(UUID fromID, UUID toID, int amount, int type, string description)
{
if (toID != UUID.Zero)
{
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
bool paid = false;
foreach (IScene scene in manager.Scenes)
{
ISceneChildEntity ent = scene.GetSceneObjectPart(toID);
if (ent != null)
{
bool success = m_connector.UserCurrencyTransfer(ent.OwnerID, fromID, ent.UUID, ent.Name, UUID.Zero, "",
(uint)amount, description, (TransactionType)type, UUID.Random());
if (success)
{
FireObjectPaid(toID, fromID, amount);
}
paid = true;
break;
}
}
if (!paid)
{
m_connector.UserCurrencyTransfer(toID, fromID, (uint)amount, description,
(TransactionType)type, UUID.Random());
}
}
}
}
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
protected internal override void Awake()
{
base.Awake();
m_SceneManager = GameFrameworkEntry.GetModule <ISceneManager>();
if (m_SceneManager == null)
{
Log.Fatal("Scene manager is invalid.");
return;
}
m_SceneManager.LoadSceneSuccess += OnLoadSceneSuccess;
m_SceneManager.LoadSceneFailure += OnLoadSceneFailure;
m_SceneManager.LoadSceneUpdate += OnLoadSceneUpdate;
m_SceneManager.LoadSceneDependency += OnLoadSceneDependency;
m_SceneManager.UnloadSceneSuccess += OnUnloadSceneSuccess;
m_SceneManager.UnloadSceneFailure += OnUnloadSceneFailure;
m_GameFrameworkScene = SceneManager.GetSceneAt(BaseComponent.GameFrameworkSceneId);
if (m_GameFrameworkScene == null)
{
Log.Fatal("Game framework scene is invalid.");
return;
}
}
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
protected override void Awake()
{
base.Awake();
m_SceneManager = GameFrameworkEntry.GetModule <ISceneManager>();
if (m_SceneManager == null)
{
Log.Fatal("Scene manager is invalid.");
return;
}
m_SceneManager.LoadSceneSuccess += OnLoadSceneSuccess;
m_SceneManager.LoadSceneFailure += OnLoadSceneFailure;
m_SceneManager.LoadSceneUpdate += OnLoadSceneUpdate;
m_SceneManager.LoadSceneDependencyAsset += OnLoadSceneDependencyAsset;
m_SceneManager.UnloadSceneSuccess += OnUnloadSceneSuccess;
m_SceneManager.UnloadSceneFailure += OnUnloadSceneFailure;
m_GameFrameworkScene = SceneManager.GetSceneAt(GameEntry.GameFrameworkSceneId);
if (!m_GameFrameworkScene.IsValid())
{
Log.Fatal("Game framework scene is invalid.");
return;
}
}
public DungeonLoader(ILoadingScreenPM i_loadingPM, IBackendManager i_backend, ICurrentDungeonGameManager i_currentDungeon, ISceneManager i_sceneManager)
{
mLoadingPM = i_loadingPM;
mBackendManager = i_backend;
mCurrentDungeonData = i_currentDungeon;
mSceneManager = i_sceneManager;
}
private void Start()
{
Vector3 toCam = new Vector3(1, 1, 1);
bool useSceneViewInput = SelectionController is RuntimeSceneView;
if (!useSceneViewInput)
{
EditorCamera.transform.position = m_pivot + toCam * EditorCamDistance;
EditorCamera.transform.LookAt(m_pivot);
RuntimeTools.DrawSelectionGizmoRay = true;
}
UpdateUIState(IsInPlayMode);
AutoFocus = TogAutoFocus.isOn;
AutoUnitSnapping = TogUnitSnap.isOn;
BoundingBoxSnapping = TogBoundingBoxSnap.isOn;
ShowSelectionGizmos = TogShowGizmos.isOn;
EnableCharacters = TogEnableCharacters.isOn;
ExposeToEditor.Awaked += OnAwaked;
ExposeToEditor.Destroyed += OnDestroyed;
m_sceneManager = Dependencies.SceneManager;
if (m_sceneManager != null)
{
m_sceneManager.ActiveScene.Name = SaveFileName;
m_sceneManager.Exists(m_sceneManager.ActiveScene, exists =>
{
m_saveFileExists = exists;
LoadButton.interactable = exists;
});
}
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
// set ScreenHeight
ScreenHeight = GraphicsDevice.Viewport.Height;
// set ScreenWidth
ScreenWidth = GraphicsDevice.Viewport.Width;
// set cameraPos
cameraPos = new Vector3(ScreenWidth / 2, 0, 0);
// initialise a new sceneGraph
sceneGraph = new SceneGraph();
// initialise a new sceneManager
sceneManager = new SceneManager(sceneGraph);
// initialise a new collisionManager
collisionManager = new CollisionManager(sceneManager);
// initialise a new inputManager
inputManager = new InputManager();
// Initialise render manager
_renderManager = new RenderManager(graphics, sceneManager, Content);
// Initialise audio manager
_audioManager = new SoundManager(Content);
// initialise a new aiComponontManager
aiComponentManager = new AIComponentManager(inputManager, _audioManager, sceneManager, Content);
// initialise a new entityManager
entityManager = new EntityManager(collisionManager, sceneGraph, aiComponentManager);
// set headerLoaction
backgroundLocation = new Vector2(-ScreenWidth / 2, 0);
backgroundLocation2 = new Vector2(backgroundLocation.X + ScreenWidth + 1, 0);
backgroundLocation3 = new Vector2(-ScreenWidth / 2, 0);
backgroundLocation4 = new Vector2(-ScreenWidth / 2, 0);
// initialise
base.Initialize();
}
public Credits(
IRenderWindow renderWindow,
ISceneManager sceneManager,
IMPQProvider mpqProvider,
Func <eButtonType, IButton> createButton
)
{
this.renderWindow = renderWindow;
this.sceneManager = sceneManager;
this.mpqProvider = mpqProvider;
backgroundSprite = renderWindow.LoadSprite(ResourcePaths.CreditsBackground, Palettes.Sky);
btnExit = createButton(eButtonType.Medium);
btnExit.Text = "Exit".ToUpper();
btnExit.Location = new Point(20, 550);
btnExit.OnActivate = OnActivateClicked;
textFont = renderWindow.LoadFont(ResourcePaths.FontFormal10, Palettes.Static);
creditsText = new Stack <string>((
File.ReadAllLines(Path.Combine(Path.GetDirectoryName(Environment.GetCommandLineArgs().First()), "credits.txt"))
.Concat(mpqProvider.GetTextFile(ResourcePaths.CreditsText))
).Reverse());
}
/// <summary>
/// Constructor for the engine.
/// </summary>
/// <param name="collisionComponent">The collision component to use for collision detection.</param>
/// <param name="backgroundColour">The game background colour after flushing graphics.
/// Transparent by default.</param>
public Engine(ICollisionComponent collisionComponent, Color?backgroundColour = null)
{
// Setup graphics device manager and content directory.
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
// Set background colour.
if (backgroundColour.HasValue)
{
this.backgroundColour = backgroundColour.Value;
}
else
{
this.backgroundColour = Color.Transparent;
}
// Initialise systems.
collisionSystem = new CollisionSystem(collisionComponent);
inputSystem = new InputSystem();
loadSystem = new LoadSystem(Content);
renderSystem = new RenderSystem(graphics);
updateSystem = new UpdateSystem();
// Create scene manager and entity manager.
sceneManager = new SceneManager(collisionSystem, inputSystem, renderSystem, updateSystem);
entityManager = new EntityManager(loadSystem, sceneManager, (ISceneStateManager)sceneManager);
}
/// <summary>
/// Region side
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
protected OSDMap OnMessageReceived(OSDMap message)
{
// We need to check and see if this is an AgentStatusChange
if (message.ContainsKey("Method") && message ["Method"] == "UpdateAvatarAppearance")
{
var appearance = new AvatarAppearance(message ["AgentID"], (OSDMap)message ["Appearance"]);
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager> ();
if (manager != null)
{
foreach (IScene scene in manager.Scenes)
{
IScenePresence sp = scene.GetScenePresence(appearance.Owner);
if (sp != null && !sp.IsChildAgent)
{
var avappmodule = sp.RequestModuleInterface <IAvatarAppearanceModule> ();
if (avappmodule != null)
{
avappmodule.Appearance = appearance;
avappmodule.SendAppearanceToAgent(sp);
avappmodule.SendAppearanceToAllOtherAgents();
}
}
}
}
}
return(null);
}
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
protected internal override void Awake()
{
base.Awake();
m_SoundManager = GameFrameworkEntry.GetModule <ISoundManager>();
if (m_SoundManager == null)
{
Log.Fatal("Sound manager is invalid.");
return;
}
m_SoundManager.PlaySoundSuccess += OnPlaySoundSuccess;
m_SoundManager.PlaySoundFailure += OnPlaySoundFailure;
m_SoundManager.PlaySoundUpdate += OnPlaySoundUpdate;
m_SoundManager.PlaySoundDependencyAsset += OnPlaySoundDependencyAsset;
m_SceneManager = GameFrameworkEntry.GetModule <ISceneManager>();
if (m_SceneManager == null)
{
Log.Fatal("Scene manager is invalid.");
return;
}
m_SceneManager.LoadSceneSuccess += OnLoadSceneSuccess;
m_SceneManager.LoadSceneFailure += OnLoadSceneFailure;
m_SceneManager.UnloadSceneSuccess += OnUnloadSceneSuccess;
m_SceneManager.UnloadSceneFailure += OnUnloadSceneFailure;
}
private void Initialize(IPlayerLocator player_locator, ISceneManager scene_manager, INetworkEngineConnector network_connector)
{
scene_manager.OnRoomLoaded
.Subscribe(_ =>
{
SubscribeEvents();
})
.AddTo(this);
network_connector.OnJoinedRoomAsObservable
.Subscribe(_ =>
{
m_AvatarSpawner = new PlayerAvatarSpawner(m_RuntimeModelLoader, player_locator);
m_AvatarSpawner.Spawn(AvatarPath, m_SpawnPosTag);
})
.AddTo(this);
network_connector.OnLeftRoomAsObservable
.Subscribe(_ =>
{
UnsubscribeEvents();
DestroyAvatar();
})
.AddTo(this);
m_RuntimeModelLoader.OnLoadModelCompleted
.Subscribe(model =>
{
m_AvatarModel = model;
m_LoadModelCompleted.OnNext(model);
})
.AddTo(this);
}
/// <summary>
/// Iterates through all Scenes, doing a deep scan through assets
/// to cache all assets present in the scene or referenced by assets
/// in the scene
/// </summary>
/// <returns></returns>
private int CacheScenes()
{
//Make sure this is not null
if (m_AssetService == null)
{
return(0);
}
Dictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType>();
ISceneManager manager = m_simulationBase.ApplicationRegistry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
UuidGatherer gatherer = new UuidGatherer(m_AssetService);
StampRegionStatusFile(manager.Scene.RegionInfo.RegionID);
manager.Scene.ForEachSceneEntity(e => gatherer.GatherAssetUuids(e, assets, manager.Scene));
foreach (UUID assetID in assets.Keys)
{
string filename = GetFileName(assetID.ToString());
if (File.Exists(filename))
{
File.SetLastAccessTime(filename, DateTime.Now);
}
else
{
m_AssetService.Get(assetID.ToString());
}
}
}
return(assets.Keys.Count);
}
public GameScene(Game game, ISceneManager sceneManager, IGraphicsSystem graphicsSystem, IGameSettings gameSettings, IGameLogger logger, IGameKeys gameKeys) : base(
game, sceneManager, graphicsSystem, gameSettings, logger, gameKeys)
{
_spriteBatch = new SpriteBatch(Game.GraphicsDevice);
_debugBatch = new SpriteBatch(Game.GraphicsDevice);
_uiBatch = new SpriteBatch(Game.GraphicsDevice);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
// INITIALISE the EntityManager variable
_entityMgr = new EntityManager();
// INITIALISE the SceneManager variable
_sceneMgr = new SceneManager();
// INITIALISE the CollisionManager variable
// PASSING IN reference to the SceneMgr.SceneEntitiesDelegate method
// as well a new QuadTree whos position is set to 0,0 and width and height is the screen width and height
_collisionMgr = new CollisionManager(_sceneMgr.SceneEntitiesDelegate, _sceneMgr.StaticEntitiesDelegate,
new QuadTree <IShape>(new Rectangle(0, 0, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight),
1));
// INITIALISE the MindManager variable
_mindMgr = new MindManager();
// INITIALISE the InputManager variable
_inputMgr = new InputManager(PauseGameState);
// INITIALISE the level to the first level
// FUTURE IMPROVEMENT ------ possibly in the future make the level selectable
_levelX = new SplashScreen();
// CALL to InjectManagers into the level selected
(_levelX as IManagerInject).InjectManagers(_entityMgr, _collisionMgr,
_inputMgr, _sceneMgr, _mindMgr, Content);
// Give the splash screen a rectangle
(_levelX as SplashScreen).TitleArea = new Rectangle(0, 0, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight);
// CALL to Initialise the current level
_levelX.Initialise();
base.Initialize();
}
/// <summary>
/// 游戏框架组件初始化。
/// </summary>
protected override void Awake()
{
base.Awake();
m_SoundManager = GameFrameworkEntry.GetModule <ISoundManager>();
if (m_SoundManager == null)
{
Log.Fatal("Sound manager is invalid.");
return;
}
m_SoundManager.PlaySoundSuccess += OnPlaySoundSuccess;
m_SoundManager.PlaySoundFailure += OnPlaySoundFailure;
m_SoundManager.PlaySoundUpdate += OnPlaySoundUpdate;
m_SoundManager.PlaySoundDependencyAsset += OnPlaySoundDependencyAsset;
m_AudioListener = gameObject.GetOrAddComponent <AudioListener>();
#if UNITY_5_4_OR_NEWER
SceneManager.sceneLoaded += OnSceneLoaded;
SceneManager.sceneUnloaded += OnSceneUnloaded;
#else
ISceneManager sceneManager = GameFrameworkEntry.GetModule <ISceneManager>();
if (sceneManager == null)
{
Log.Fatal("Scene manager is invalid.");
return;
}
sceneManager.LoadSceneSuccess += OnLoadSceneSuccess;
sceneManager.LoadSceneFailure += OnLoadSceneFailure;
sceneManager.UnloadSceneSuccess += OnUnloadSceneSuccess;
sceneManager.UnloadSceneFailure += OnUnloadSceneFailure;
#endif
}
private OSDMap syncRecievedService_OnMessageReceived(OSDMap message)
{
string method = message["Method"];
if (method == "SendInstantMessages")
{
List <GridInstantMessage> messages =
((OSDArray)message["Messages"]).ConvertAll <GridInstantMessage>((o) =>
{
GridInstantMessage im =
new GridInstantMessage();
im.FromOSD((OSDMap)o);
return(im);
});
ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>();
if (manager != null)
{
IMessageTransferModule messageTransfer =
manager.Scene.RequestModuleInterface <IMessageTransferModule>();
if (messageTransfer != null)
{
foreach (GridInstantMessage im in messages)
{
messageTransfer.SendInstantMessage(im);
}
}
}
}
return(null);
}
public CharacterSelection(IRenderWindow renderWindow,
ISceneManager sceneManager, ITextDictionary textDictionary, Func <eButtonType, IButton> createButton)
{
this.renderWindow = renderWindow;
backgroundSprite = renderWindow.LoadSprite(ResourcePaths.CharacterSelectionBackground, Palettes.Sky);
createNewCharacterButton = createButton(eButtonType.Tall);
// TODO: use strCreateNewCharacter -- need to get the text to split after 10 chars though.
createNewCharacterButton.Text = textDictionary.Translate("strCreateNewCharacter");// "Create New".ToUpper();
createNewCharacterButton.Location = new Point(33, 467);
createNewCharacterButton.OnActivate = () => sceneManager.ChangeScene(eSceneType.SelectHeroClass);
deleteCharacterButton = createButton(eButtonType.Tall);
deleteCharacterButton.Text = textDictionary.Translate("strDelete");
deleteCharacterButton.Location = new Point(433, 467);
exitButton = createButton(eButtonType.Medium);
exitButton.Text = textDictionary.Translate("strExit");
exitButton.Location = new Point(33, 540);
exitButton.OnActivate = () => sceneManager.ChangeScene(eSceneType.MainMenu);
okButton = createButton(eButtonType.Medium);
okButton.Text = textDictionary.Translate("strOk");
okButton.Location = new Point(630, 540);
okButton.Enabled = false;
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
// set ScreenHeight
ScreenHeight = GraphicsDevice.Viewport.Height;
// set ScreenWidth
ScreenWidth = GraphicsDevice.Viewport.Width;
// set cameraPos
cameraPos = new Vector3(ScreenWidth / 2, 0, 0);
// initialise a new sceneGraph
sceneGraph = new SceneGraph();
// initialise a new sceneManager
sceneManager = new SceneManager(sceneGraph);
// initialise a new collisionManager
collisionManager = new CollisionManager(sceneManager);
// initialise a new inputManager
inputManager = new InputManager();
// initialise a new aiComponontManager
aiComponentManager = new AIComponentManager(inputManager);
// initialise a new entityManager
entityManager = new EntityManager(collisionManager, sceneGraph, aiComponentManager);
// initialise a new engineDemo
gameDemo = new GameDemo();
// run engineDemo initialise method
gameDemo.Initialise(entityManager, sceneManager, collisionManager, aiComponentManager, inputManager, sceneGraph);
// add input listeners to the engineDemo
inputManager.AddListener(((IKeyboardListener)gameDemo).OnNewKeyboardInput);
inputManager.AddListener(((IMouseListener)gameDemo).OnNewMouseInput);
// set headerLoaction
headerLocation = new Vector2(-ScreenWidth / 2, 0);
// initialise
base.Initialize();
}
public SpawnerManager()
{
this._sceneManager = null; // post init
this._spawnRequestConcurrentQueue = new ConcurrentQueue<GameObjectSpawnRequest>();
this._removeGameObjectRequestConcurrentQueue = new ConcurrentQueue<IGameObject>();
this._firstTime = true;
}
public RGBA_D Shade(Ray ray, Vector3D pos, uint subIdx, out Ray reflection, out Ray refraction,
ISceneManager scene)
{
if (shader != null)
return shader.Shade(ray, pos, subIdx, this, scene, out reflection, out refraction);
reflection = null;
refraction = null;
return RGBA_D.Empty;
}
public Ray(Vector3D origin, Vector3D directionUV, double intensity,
double length, double maxLength, ISceneManager scene)
{
this.origin = origin;
this.directionUV = directionUV;
this.intensity = intensity;
this.length = length;
this.maxLength = maxLength;
this.scene = scene;
}
public RayGroup(bool divide, double maxLength,
Rectangle area, ISceneManager scene, IRayDispatch dispatch,
FrameData frameData, CameraView view)
{
this.divide = divide;
this.maxLength = maxLength;
this.area = area;
this.scene = scene;
this.dispatch = dispatch;
this.frameData = frameData;
this.view = view;
}
//Show Pause screen with P
public override void HandleKeys(InputHelper aInputHelper, ISceneManager aSceneManager)
{
//Show Pause Screen
if (aInputHelper.IsNewPress(Keys.P))
{
aSceneManager.ShowOverlay(new Pause());
}
//Show The exit screen
if (aInputHelper.IsNewPress(Keys.Escape))
{
aSceneManager.ShowOverlay(new ExitGameIntsance());
}
}
public void awaken()
{
if (this._firstTime)
{
this._sceneManager = GameLoop.getSceneManager();
this.addGameObjectToScene(this.spawnGameObjectsOnStart());
this._firstTime = false;
}
this.processSpecialSpawnRequest();
this.addGameObjectToScene(this.spawnGameObjectsPerFrame());
this.processSpecialRemoveRequest();
}
/// <summary>
///
/// </summary>
private GameLoop()
{
this.gameStillRunning = true;
this.sceneManager = null;
this.sceneBrain = null;
this.spawnerManager = null;
this.updateRenderer = null;
this.timerManager = null;
this.collisionManager = null;
gameLoopThread = new Thread(new ThreadStart(this.runLoop));
gameLoopThread.SetApartmentState(ApartmentState.STA);
gameLoopThread.Name = "GameLoopThread";
gameLoopThread.IsBackground = true; //ensures that will be terminated on application close
}
public override void HandleKeys(InputHelper aInputHelper, ISceneManager aSceneManager)
{
//Close/Quit :)
if(aInputHelper.IsNewPress(Keys.Q) || aInputHelper.IsNewPress(Keys.Enter) || aInputHelper.IsNewPress(Keys.Y))
{
Game1.ForceClose();
return;
}
//We don't want to close quit - return to previous screen
if (aInputHelper.IsNewPress(Keys.N) || aInputHelper.IsNewPress(Keys.Back))
{
aSceneManager.HideOverlay();
return;
}
}
private void NextScene()
{
if (sceneManager != null)
{
sceneManager.Finish -= SceneManager_Finish;
sceneManager.Destroy();
}
if (sceneManager == null)
sceneManager = new Scene1Manager();
else if (sceneManager is Scene1Manager)
sceneManager = new Scene2Manager();
else if (sceneManager is Scene2Manager)
sceneManager = new Scene3Manager();
else
Application.Exit();
sceneManager.Finish += SceneManager_Finish;
sceneManager.Init();
}
public override void HandleKeys(InputHelper aInputHelper, ISceneManager aSceneManager)
{
//Does the user want to quit?
if (aInputHelper.IsNewPress(Keys.Q) || aInputHelper.IsNewPress(Keys.Escape))
{
aSceneManager.ShowOverlay(new ExitGameIntsance());
return;
}
//Else - Let's be silly!
if (aInputHelper.IsCurPress(Keys.E) &&
aInputHelper.IsCurPress(Keys.W) &&
aInputHelper.IsCurPress(Keys.A) &&
aInputHelper.IsCurPress(Keys.N))
{
//aSceneManager.SetScene(new SuperSpecialAwesomeScene());
Console.WriteLine("Dylan smells!");
return;
}
}
public RGBA_D Shade(Ray ray, Vector3D hitPoint, uint subIdx, IOpticalSceneObject obj,
ISceneManager scene, out Ray reflection, out Ray refraction)
{
RGBA_D color = RGBA_D.Empty;
// needed?
// normal.Normalize();
Vector3D normal = obj.GetNormal(hitPoint, subIdx);
//color.R = normal.X * 255;
//color.G = normal.Y * 255;
//color.B = normal.Z * 255;
//color.A = 255;
//refraction = null;
//reflection = null;
//return color;
/*double len = (ray.Origin - hitPoint).Length();
len -= 2;
color.R = color.G = color.B = len * 42.5;*/
foreach (Light light in scene.Lights)
{
Vector3D lv = light.Position - hitPoint;
lv.Normalize();
// deal with light ray first (diffuse)
if (true)//ray.TraceRayToLight(hitPoint, light.Position))
{
// light pixel
double cost = Vector3D.GetCosAngle(lv, normal);
Vector3D vRefl = Vector3D.Reflect(-lv, normal);
vRefl.Normalize();
double cosf = Vector3D.GetCosAngle(ray.DirectionUV, vRefl);
double result1 = Math.Max(0, cost) * 255;
double result2 = Math.Pow(Math.Max(0, cosf), shininess) * 255;
double luminosity = light.LuminosityForPoint(hitPoint);
double r = ((clr.R * diffuse * light.Clr3D.X * result1) +
(light.Clr3D.X * result2)) * luminosity;
double g = ((clr.G * diffuse * light.Clr3D.Y * result1) +
(light.Clr3D.Y * result2)) * luminosity;
double b = ((clr.B * diffuse * light.Clr3D.Z * result1) +
(light.Clr3D.Z * result2)) * luminosity;
color.R += r;
color.G += g;
color.B += b;
}
}
// add ambient
double alpha = 1 - transmission;
color.R += (diffuse * scene.Ambient.R + (clr.R * emmissive)) * 255;
//color.R *= alpha;
color.G += (diffuse * scene.Ambient.G + (clr.G * emmissive)) * 255;
//color.G *= alpha;
color.B += (diffuse * scene.Ambient.B + (clr.B * emmissive)) * 255;
//color.B *= alpha;
color.A = alpha * 255;
// blend texture (if any)
/*if (texture != null)
{
Vector2D tCoord = obj.GetTexCoord(hitPoint, subIdx);
// clamp for now
if (tCoord.X < 0)
tCoord.X = 0;
if (tCoord.Y < 0)
tCoord.Y = 0;
if (tCoord.X > 1)
tCoord.X = 1;
if (tCoord.Y > 1)
tCoord.Y = 1;
int tX = (int)(tCoord.X * (texture.Width - 1));
int tY = (int)(tCoord.Y * (texture.Height - 1));
Color tClr = ((Bitmap)texture).GetPixel(tX, tY);
color.R = (color.R + tClr.R) / 2;
color.G = (color.G + tClr.G) / 2;
color.B = (color.B + tClr.B) / 2;
}*/
if (ray.Intensity > 0)
{
/*if (this.reflection > 0)
{
Vector3D refl = Vector3D.Reflect(ray.DirectionUV, normal);
reflection = new Ray(hitPoint, refl, ray.Intensity * this.reflection, ray.Length, ray.MaxLength, ray.scene);
}
else*/
reflection = null;
/*if (transmission > 0)
refraction = new Ray(hitPoint, Vector3D.Normalize(Vector3D.Refract(1, 1.33, -ray.DirectionUV, normal)), ray.Intensity * transmission, ray.Length, ray.MaxLength, ray.scene);
else*/
refraction = null;
}
else
reflection = refraction = null;
ray.Intensity = 0;
return color;
}
public ExitState(ISceneManager sceneManager, ILogManager logManager, IMessageManager messageManager)
: base("exit", null, sceneManager, logManager)
{
this.MessageManager = messageManager;
}
/// <summary>
/// Is invoked by <see cref="Mortar.Events.Incidents.GameStarted"/>.
/// </summary>
public void OnGameStarted(IEvent e)
{
try
{
SceneManager = new UnitySceneManager();
PrepareConsistentObjects();
}
catch(Exception expection)
{
Logger.LogException(expection);
}
}
public abstract void HandleKeys(InputHelper aInputHelper, ISceneManager aSceneManager);
public TestState( ILogManager logManager, ISceneManager sceneManager, ISystemsManager systemsManager )
: base("test", null, sceneManager, logManager)
{
this.SystemsManager = systemsManager;
}
public void Initialize(ISimulationBase simBase)
{
_regionInfoConnector = Aurora.DataManager.DataManager.RequestPlugin<IRegionInfoConnector>();
_sceneManager = m_registry.RequestModuleInterface<ISceneManager>();
}
public void Initialize(ISimulationBase simBase)
{
_sceneManager = m_registry.RequestModuleInterface<ISceneManager>();
}
public TestState( ILogManager logManager, ISceneManager sceneManager, ISystemsManager systemsManager, IMessageManager messageManager )
: base("test", null, sceneManager, logManager, new ExitState( sceneManager, logManager, messageManager ))
{
this.SystemsManager = systemsManager;
}
public void PostFinishStartup(IScene scene, IConfigSource source, ISimulationBase openSimBase)
{
m_manager = scene.RequestModuleInterface<ISceneManager>();
m_backup[scene].FinishStartup();
}
public SmTestState( ISceneManager scm, ILogManager lm )
: base("test", "init", scm, lm)
{
}
public void Initialize(RegionInfo regionInfo, ISimulationDataStore dataStore,
AgentCircuitManager authen, List<IClientNetworkServer> clientServers)
{
Initialize(regionInfo);
//Set up the clientServer
m_clientServers = clientServers;
foreach (IClientNetworkServer clientServer in clientServers)
{
clientServer.AddScene(this);
}
m_sceneManager = RequestModuleInterface<ISceneManager>();
m_simDataStore = dataStore;
m_config = m_sceneManager.ConfigSource;
m_authenticateHandler = authen;
m_AuroraEventManager = new AuroraEventManager();
m_eventManager = new EventManager();
m_permissions = new ScenePermissions(this);
m_sceneGraph = new SceneGraph(this, m_regInfo);
#region Region Config
IConfig aurorastartupConfig = m_config.Configs["AuroraStartup"];
if (aurorastartupConfig != null)
{
//Region specific is still honored here, the RegionInfo checks for it, and if it is 0, it didn't set it
if (RegionInfo.ObjectCapacity == 0)
RegionInfo.ObjectCapacity = aurorastartupConfig.GetInt("ObjectCapacity", 80000);
}
IConfig packetConfig = m_config.Configs["PacketPool"];
if (packetConfig != null)
{
PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true);
PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true);
}
#endregion Region Config
m_basesimfps = 45f;
m_basesimphysfps = 45f;
m_basesimphysfps = Config.Configs["Physics"].GetFloat("BasePhysicsFPS", 45f);
if (m_basesimphysfps > 45f)
m_basesimphysfps = 45f;
m_basesimfps = Config.Configs["Protection"].GetFloat("BaseRateFramesPerSecond", 45f);
if (m_basesimfps > 45f)
m_basesimfps = 45f;
if (m_basesimphysfps > m_basesimfps)
m_basesimphysfps = m_basesimfps;
m_updatetimespan = 1000/m_basesimfps;
m_physicstimespan = 1000/m_basesimphysfps;
#region Startup Complete config
EventManager.OnAddToStartupQueue += AddToStartupQueue;
EventManager.OnModuleFinishedStartup += FinishedStartup;
//EventManager.OnStartupComplete += StartupComplete;
AddToStartupQueue("Startup");
#endregion
}
/// <summary>
///
/// </summary>
/// <param name="sceneManager"></param>
public void setSceneManager(ISceneManager sceneManager)
{
this.sceneManager = sceneManager;
}
/// <summary>
/// remove IGameObject's pair are no longer in collision
/// </summary>
public void removeNotCollidableElementsInCurrentFrame(ISceneManager sceneManager)
{
if (collisionStateMapByGameObjectPair.Count > 0)
{
for (int i=0; i < collisionStateMapByGameObjectPair.Count; i++ )
{
//foreach (KeyValuePair<KeyValuePair<IGameObject, IGameObject>, bool> dictionaryElement in collisionRecordDictionary)
//{
//if (collisionRecordDictionary[dictionaryElement.Key] == false)
//{
// collisionRecordDictionary.Remove(dictionaryElement.Key);
// dictionaryElement.Key.Key.onCollisionExitDelegate(dictionaryElement.Key.Value);
// dictionaryElement.Key.Value.onCollisionExitDelegate(dictionaryElement.Key.Key);
//}
KeyValuePair<IGameObject, IGameObject> gameObjectPair = collisionStateMapByGameObjectPair.ElementAt(i).Key;
if (collisionStateMapByGameObjectPair[gameObjectPair] == false)
{
List<IGameObject> firstGameObjectList = sceneManager.getCollaidableGameObjectList(gameObjectPair.Key.getGameObjectTag());
List<IGameObject> secondGameObjectList = sceneManager.getCollaidableGameObjectList(gameObjectPair.Value.getGameObjectTag());
if(firstGameObjectList.Contains(gameObjectPair.Key)){
gameObjectPair.Key.onCollisionExitDelegate(gameObjectPair.Value);
}
if (secondGameObjectList.Contains(gameObjectPair.Value))
{
gameObjectPair.Value.onCollisionExitDelegate(gameObjectPair.Key);
}
//remove element from dictionary
collisionStateMapByGameObjectPair.Remove(gameObjectPair);
}
}
}
}
public override void HandleKeys(InputHelper aInputHelper, ISceneManager aSceneManager)
{
return;
}
