public static void StartGame(RuntimeConfig runtimeConfig) { CheckRunnerIsFree(); Quantum.Log.Info("Starting Game"); if (runtimeConfig.GameMode == DeterministicGameMode.Multiplayer) { if (PhotonNetwork.connected == false) { throw new Exception("Not connected to photon"); } if (PhotonNetwork.inRoom == false) { throw new Exception("Can't start networked game when not in a room"); } if (runtimeConfig.Players.Length != PhotonNetwork.room.MaxPlayers) { throw new Exception("Less RuntimePlayer instances provided on RuntimeConfig than MaxPlayers set on room"); } } Current = CreateInstance(); Current._session = new DeterministicSession(DeterministicSessionConfigAsset.Instance.Config, new QuantumGame(runtimeConfig), GetCommunicator(runtimeConfig), runtimeConfig); }
void Start() { if (PhotonNetwork.connected) { return; } if (QuantumRunner.Current) { return; } Debug.Log("### Starting quantum in local debug mode ###"); var mapdata = FindObjectOfType <MapData>(); if (mapdata) { // set singleplayer Config.GameMode = Photon.Deterministic.DeterministicGameMode.Local; // set map to this maps asset Config.Map.Guid = mapdata.Asset.AssetObject.Guid; // start with debug config QuantumRunner.StartGame(Config); } else { throw new Exception("No MapData object found, can't debug start scene"); } }
void Start() { // init runtime QuantumRunner.Init(); // init database UnityDB.Init(); }
public static void Init(Boolean force = false) { if (_byIndex != null && force == false) { return; } // init runtime QuantumRunner.Init(); // init layers Quantum.Layers.Init(GetUnityLayerNameArray(), GetUnityLayerMatrix()); _byIndex = LoadAll(); _byGuid = new Dictionary <String, AssetBase>(); foreach (var asset in _byIndex) { if (asset) { _byGuid.Add(asset.AssetObject.Guid, asset); } } List <AssetObject> navMeshes = new List <AssetObject>(); int nextId = _byIndex.Length; foreach (var asset in _byIndex) { if (asset) { try { asset.Loaded(); var map = asset as MapAsset; if (map != null) { foreach (var navMesh in map.Settings.NavMeshes.Values) { navMesh.Id = nextId++; navMesh.Guid = "NavMesh" + navMesh.Id; navMeshes.Add(navMesh); } } } catch (Exception exn) { Log.Exception(exn); } } } var data = _byIndex.MapRef(x => x.AssetObject); data = data.Concat <AssetObject>(navMeshes).ToArray <AssetObject>(); DB.Init(data); Debug.Log("Quantum Asset Database Loaded"); }
public QuantumGame(Quantum.RuntimeConfig runtimeConfig) { // init debug QuantumRunner.Init(); // initialize db UnityDB.Init(); _runtimeConfig = RuntimeConfig = runtimeConfig; _simulationConfig = SimulationConfig = SimulationConfigAsset.Instance.Configuration; _systems = Quantum.SystemSetup.CreateSystems(_runtimeConfig, _simulationConfig); IsReplay = runtimeConfig.GameMode == DeterministicGameMode.Replay; IsReplayFinished = false; // set system runtime indices for (Int32 i = 0; i < _systems.Length; ++i) { _systems[i].RuntimeIndex = i; } }
void CheckForGameStart() { if (_started) { return; } var start = false; var map = default(String); if (TryGetRoomProperty <Boolean>("START", out start) && TryGetRoomProperty <String>("MAP", out map)) { if (start && String.IsNullOrEmpty(map) == false) { _started = true; RuntimeConfig config; config = new RuntimeConfig(); config.Players = new RuntimePlayer[PhotonNetwork.room.MaxPlayers]; for (Int32 i = 0; i < config.Players.Length; ++i) { config.Players[i] = new RuntimePlayer(); config.Players[i].CharacterSpec.Guid = "mage"; } config.Map.Guid = UnityDB.AllOf <MapAsset>().First(x => x.Settings.Scene == map).Settings.Guid; config.GameMode = Photon.Deterministic.DeterministicGameMode.Multiplayer; QuantumRunner.StartGame(config); UIRoom.HideScreen(); UILeaveGame.ShowScreen(); } } }
/* * [MenuItem("Assets/Export Mecanim Animation Controller", false, 301)] * private static void CreateAnimatorFile() { * var animatorController = Selection.activeObject as AnimatorController; * if (animatorController == null) { * return; * } * * CreateAsset(animatorController); * } * * [MenuItem("Assets/Export Mecanim Animation Controller", true)] * private static bool CreateAnimatorController() { * return Selection.activeObject is AnimatorController; * } */ // public static AnimatorGraphAsset Fetch(string name) { // AnimatorGraphAsset output = null; //#if UNITY_EDITOR // string pathToAnimationResource = "Assets/Resources/DB/Animator/"; // string animationFilePath = pathToAnimationResource + name + ".asset"; // output = UnityEditor.AssetDatabase.LoadAssetAtPath(animationFilePath, typeof(AnimatorGraphAsset)) as AnimatorGraphAsset; // if (output == null) { // output = CreateInstance<AnimatorGraphAsset>(); // animationFilePath = UnityEditor.AssetDatabase.GenerateUniqueAssetPath(animationFilePath); // UnityEditor.AssetDatabase.CreateAsset(output, animationFilePath); // UnityEditor.AssetDatabase.SaveAssets(); // UnityEditor.AssetDatabase.Refresh(); // } //#endif // if (output != null) { // if (output.Settings == null) // output.Settings = new AnimatorGraph(); // } // return output; // } public static void CreateAsset(AnimatorGraphAsset dataAsset, AnimatorController controller) { if (!controller) { return; } if (!dataAsset) { return; } QuantumRunner.Init();//make sure we can get debug calls from Quantum dataAsset.controller = controller; int weightTableResolution = (int)dataAsset.weight_table_resolution; int variableCount = controller.parameters.Length; dataAsset.Settings.variables = new AnimatorVariable[variableCount]; //Mecanim Parameters/Variables //make a dictionary of paramets by name for use when extracting conditions for transitions Dictionary <string, AnimatorControllerParameter> parameterDic = new Dictionary <string, AnimatorControllerParameter>(); for (int v = 0; v < variableCount; v++) { AnimatorControllerParameter parameter = controller.parameters[v]; parameterDic.Add(parameter.name, parameter); AnimatorVariable newVariable = new AnimatorVariable(); newVariable.name = parameter.name; newVariable.index = v; switch (parameter.type) { case AnimatorControllerParameterType.Bool: newVariable.type = AnimatorVariable.VariableType.Bool; newVariable.defaultBool = parameter.defaultBool; break; case AnimatorControllerParameterType.Float: newVariable.type = AnimatorVariable.VariableType.FP; newVariable.defaultFp = FP.FromFloat_UNSAFE(parameter.defaultFloat); break; case AnimatorControllerParameterType.Int: newVariable.type = AnimatorVariable.VariableType.Int; newVariable.defaultInt = parameter.defaultInt; break; case AnimatorControllerParameterType.Trigger: newVariable.type = AnimatorVariable.VariableType.Trigger; break; } dataAsset.Settings.variables[v] = newVariable; } //Mecanim State Graph int layerCount = controller.layers.Length; dataAsset.clips.Clear(); dataAsset.Settings.layers = new AnimatorLayer[layerCount]; for (int l = 0; l < layerCount; l++) { AnimatorLayer newLayer = new AnimatorLayer(); newLayer.name = controller.layers[l].name; newLayer.id = l; int stateCount = controller.layers[l].stateMachine.states.Length; newLayer.states = new Quantum.AnimatorState[stateCount + 1];//additional element for the any state Dictionary <UnityEditor.Animations.AnimatorState, Quantum.AnimatorState> stateDictionary = new Dictionary <AnimatorState, Quantum.AnimatorState>(); for (int s = 0; s < stateCount; s++) { UnityEditor.Animations.AnimatorState state = controller.layers[l].stateMachine.states[s].state; Quantum.AnimatorState newState = new Quantum.AnimatorState(); newState.name = state.name; newState.id = state.nameHash; newState.isDefault = controller.layers[l].stateMachine.defaultState == state; newState.speed = FP.FromFloat_UNSAFE(state.speed); newState.cycleOffset = FP.FromFloat_UNSAFE(state.cycleOffset); if (state.motion != null) { AnimationClip clip = state.motion as AnimationClip; if (clip != null) { dataAsset.clips.Add(clip); AnimatorClip newClip = new AnimatorClip(); newClip.name = state.motion.name; newClip.data = Extract(clip); newState.motion = newClip; } else { BlendTree tree = state.motion as BlendTree; if (tree != null) { int childCount = tree.children.Length; AnimatorBlendTree newBlendTree = new AnimatorBlendTree(); newBlendTree.name = state.motion.name; newBlendTree.motionCount = childCount; newBlendTree.motions = new AnimatorMotion[childCount]; newBlendTree.positions = new FPVector2[childCount]; newBlendTree.weights = new FP[childCount]; string parameterXname = tree.blendParameter; string parameterYname = tree.blendParameterY; for (int v = 0; v < variableCount; v++) { if (controller.parameters[v].name == parameterXname) { newBlendTree.blendParameterIndex = v; } if (controller.parameters[v].name == parameterYname) { newBlendTree.blendParameterIndexY = v; } } for (int c = 0; c < childCount; c++) { ChildMotion cMotion = tree.children[c]; AnimationClip cClip = cMotion.motion as AnimationClip; newBlendTree.positions[c] = new FPVector2(FP.FromFloat_UNSAFE(cMotion.position.x), FP.FromFloat_UNSAFE(cMotion.position.y)); if (cClip != null) { dataAsset.clips.Add(cClip); AnimatorClip newClip = new AnimatorClip(); newClip.data = Extract(cClip); newClip.name = newClip.clipName; newBlendTree.motions[c] = newClip; } } FP val = FP._0 / 21; newBlendTree.CalculateWeightTable(weightTableResolution); newState.motion = newBlendTree; } } } newLayer.states[s] = newState; stateDictionary.Add(state, newState); } //State Transistions //once the states have all been created //we'll hook up the transitions for (int s = 0; s < stateCount; s++) { UnityEditor.Animations.AnimatorState state = controller.layers[l].stateMachine.states[s].state; Quantum.AnimatorState newState = newLayer.states[s]; int transitionCount = state.transitions.Length; newState.transitions = new Quantum.AnimatorTransition[transitionCount]; for (int t = 0; t < transitionCount; t++) { AnimatorStateTransition transition = state.transitions[t]; if (!stateDictionary.ContainsKey(transition.destinationState)) { continue; } Quantum.AnimatorTransition newTransition = new Quantum.AnimatorTransition(); newTransition.index = t; newTransition.name = string.Format("{0} to {1}", state.name, transition.destinationState.name); newTransition.duration = FP.FromFloat_UNSAFE(transition.duration * state.motion.averageDuration); newTransition.hasExitTime = transition.hasExitTime; newTransition.exitTime = FP.FromFloat_UNSAFE(transition.exitTime * state.motion.averageDuration); newTransition.offset = FP.FromFloat_UNSAFE(transition.offset * transition.destinationState.motion.averageDuration); newTransition.destinationStateId = stateDictionary[transition.destinationState].id; newTransition.destinationStateName = stateDictionary[transition.destinationState].name; newTransition.canTransitionToSelf = transition.canTransitionToSelf; int conditionCount = transition.conditions.Length; newTransition.conditions = new Quantum.AnimatorCondition[conditionCount]; for (int c = 0; c < conditionCount; c++) { UnityEditor.Animations.AnimatorCondition condition = state.transitions[t].conditions[c]; if (!parameterDic.ContainsKey(condition.parameter)) { continue; } AnimatorControllerParameter parameter = parameterDic[condition.parameter]; Quantum.AnimatorCondition newCondition = new Quantum.AnimatorCondition(); newCondition.variableName = condition.parameter; newCondition.mode = (Quantum.AnimatorCondition.Modes)condition.mode; switch (parameter.type) { case AnimatorControllerParameterType.Float: newCondition.thresholdFp = FP.FromFloat_UNSAFE(condition.threshold); break; case AnimatorControllerParameterType.Int: newCondition.thresholdInt = Mathf.RoundToInt(condition.threshold); break; } newTransition.conditions[c] = newCondition; } newState.transitions[t] = newTransition; } } //Create Any State Quantum.AnimatorState anyState = new Quantum.AnimatorState(); anyState.name = "Any State"; anyState.id = anyState.name.GetHashCode(); anyState.isAny = true;//important for this one AnimatorStateTransition[] anyStateTransitions = controller.layers[l].stateMachine.anyStateTransitions; int anyStateTransitionCount = anyStateTransitions.Length; anyState.transitions = new Quantum.AnimatorTransition[anyStateTransitionCount]; for (int t = 0; t < anyStateTransitionCount; t++) { AnimatorStateTransition transition = anyStateTransitions[t]; if (!stateDictionary.ContainsKey(transition.destinationState)) { continue; } Quantum.AnimatorTransition newTransition = new Quantum.AnimatorTransition(); newTransition.index = t; newTransition.name = string.Format("Any State to {0}", transition.destinationState.name); newTransition.duration = FP.FromFloat_UNSAFE(transition.duration); newTransition.hasExitTime = transition.hasExitTime; newTransition.exitTime = FP._1; newTransition.offset = FP.FromFloat_UNSAFE(transition.offset * transition.destinationState.motion.averageDuration); newTransition.destinationStateId = stateDictionary[transition.destinationState].id; newTransition.destinationStateName = stateDictionary[transition.destinationState].name; newTransition.canTransitionToSelf = transition.canTransitionToSelf; int conditionCount = transition.conditions.Length; newTransition.conditions = new Quantum.AnimatorCondition[conditionCount]; for (int c = 0; c < conditionCount; c++) { UnityEditor.Animations.AnimatorCondition condition = anyStateTransitions[t].conditions[c]; if (!parameterDic.ContainsKey(condition.parameter)) { continue; } AnimatorControllerParameter parameter = parameterDic[condition.parameter]; Quantum.AnimatorCondition newCondition = new Quantum.AnimatorCondition(); newCondition.variableName = condition.parameter; newCondition.mode = (Quantum.AnimatorCondition.Modes)condition.mode; switch (parameter.type) { case AnimatorControllerParameterType.Float: newCondition.thresholdFp = FP.FromFloat_UNSAFE(condition.threshold); break; case AnimatorControllerParameterType.Int: newCondition.thresholdInt = Mathf.RoundToInt(condition.threshold); break; } newTransition.conditions[c] = newCondition; } anyState.transitions[t] = newTransition; } newLayer.states[stateCount] = anyState; dataAsset.Settings.layers[l] = newLayer; } EditorUtility.SetDirty(dataAsset); }
public void Shutdown() { Destroy(gameObject); Current = null; }