protected void SharedGUITwo(AC.Char _target)
{
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Rigidbody settings:", EditorStyles.boldLabel);
_target.ignoreGravity = EditorGUILayout.Toggle("Ignore gravity?", _target.ignoreGravity);
_target.freezeRigidbodyWhenIdle = EditorGUILayout.Toggle("Freeze when Idle?", _target.freezeRigidbodyWhenIdle);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Audio clips:", EditorStyles.boldLabel);
_target.walkSound = (AudioClip)EditorGUILayout.ObjectField("Walk sound:", _target.walkSound, typeof(AudioClip), false);
_target.runSound = (AudioClip)EditorGUILayout.ObjectField("Run sound:", _target.runSound, typeof(AudioClip), false);
_target.soundChild = (Sound)EditorGUILayout.ObjectField("Sound child:", _target.soundChild, typeof(Sound), true);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Dialogue settings:", EditorStyles.boldLabel);
EditorGUILayout.LabelField("Portrait graphic:");
_target.portraitIcon.ShowGUI(false);
_target.speechColor = EditorGUILayout.ColorField("Speech text colour:", _target.speechColor);
_target.speechLabel = EditorGUILayout.TextField("Speaker label:", _target.speechLabel);
EditorGUILayout.EndVertical();
}
public virtual void Declare(AC.Char _character)
{
character = _character;
turningStyle = TurningStyle.Script;
rootMotion = false;
isSpriteBased = false;
}
override public void ShowGUI (List<ActionParameter> parameters)
{
// Action-specific Inspector GUI code here
isPlayer = EditorGUILayout.Toggle ("Is Player?", isPlayer);
if (isPlayer)
{
if (Application.isPlaying)
{
_char = KickStarter.player;
}
else
{
_char = AdvGame.GetReferences ().settingsManager.GetDefaultPlayer ();
}
}
else
{
parameterID = Action.ChooseParameterGUI ("Character:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
_char = null;
}
else
{
_char = (Char) EditorGUILayout.ObjectField ("Character:", _char, typeof (Char), true);
constantID = FieldToID <Char> (_char, constantID);
_char = IDToField <Char> (_char, constantID, false);
}
}
newPortraitGraphic = (Texture2D) EditorGUILayout.ObjectField ("New Portrait graphic:", newPortraitGraphic, typeof (Texture2D), true);
AfterRunningOption ();
}
public override void Declare(AC.Char _character)
{
character = _character;
turningStyle = TurningStyle.Linear;
rootMotion = false;
isSpriteBased = true;
}
public virtual void Declare (AC.Char _character)
{
character = _character;
turningIsLinear = false;
rootMotion = false;
isSpriteBased = false;
}
public override void AssignValues(List<ActionParameter> parameters)
{
charToMove = AssignFile <Char> (parameters, charToMoveParameterID, charToMoveID, charToMove);
if (isPlayer)
{
charToMove = KickStarter.player;
}
}
public override void AssignValues(List<ActionParameter> parameters)
{
_char = AssignFile <Char> (_charID, _char);
if (isPlayer)
{
_char = KickStarter.player;
}
}
public void FollowReset()
{
FollowStop ();
followTarget = null;
followTargetIsPlayer = false;
followFrequency = 0f;
followDistance = 0f;
}
override public void AssignValues (List<ActionParameter> parameters)
{
_char = AssignFile <Char> (parameters, parameterID, constantID, _char);
if (isPlayer)
{
_char = KickStarter.player;
}
}
override public void AssignValues (List<ActionParameter> parameters)
{
_char = AssignFile <Char> (_charID, _char);
objectToHold = AssignFile (parameters, objectToHoldParameterID, objectToHoldID, objectToHold);
if (isPlayer)
{
_char = KickStarter.player;
}
}
public override void AssignValues(List<ActionParameter> parameters)
{
speaker = AssignFile <Char> (parameters, parameterID, constantID, speaker);
messageText = AssignString (parameters, messageParameterID, messageText);
if (isPlayer)
{
speaker = KickStarter.player;
}
}
public override void AssignValues (List<ActionParameter> parameters)
{
charToMove = AssignFile <Char> (parameters, charToMoveParameterID, charToMoveID, charToMove);
faceObject = AssignFile (parameters, faceObjectParameterID, faceObjectID, faceObject);
if (isPlayer)
{
charToMove = KickStarter.player;
}
else if (facePlayer && KickStarter.player)
{
faceObject = KickStarter.player.gameObject;
}
}
override public void AssignValues (List<ActionParameter> parameters)
{
animChar = AssignFile <Char> (parameters, parameterID, constantID, animChar);
if (isPlayer)
{
animChar = KickStarter.player;
}
if (animChar && animChar.animEngine == null)
{
animChar.ResetAnimationEngine ();
}
}
public static void Stop(Char speaker)
{
if (speaker == null)
{
return;
}
#if RogoLipSyncIsPresent
if (speaker.GetComponent <RogoDigital.Lipsync.LipSync>() != null)
{
speaker.GetComponent <RogoDigital.Lipsync.LipSync>().Stop (true);
}
#endif
}
override public void ShowGUI (List<ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle ("Is Player?", isPlayer);
if (!isPlayer)
{
_char = (Char) EditorGUILayout.ObjectField ("Character:", _char, typeof (Char), true);
_charID = FieldToID <Char> (_char, _charID);
_char = IDToField <Char> (_char, _charID, true);
}
newName = EditorGUILayout.TextField ("New name:", newName);
AfterRunningOption ();
}
public override void AssignValues(List<ActionParameter> parameters)
{
_char = AssignFile <Char> (_charID, _char);
objectToHold = AssignFile (parameters, objectToHoldParameterID, objectToHoldID, objectToHold);
if (!objectToHold.activeInHierarchy)
{
loadedObject = (GameObject) Instantiate (objectToHold);
}
if (isPlayer)
{
_char = KickStarter.player;
}
}
public override Vector3[] GetPointsArray(AC.Char _char, Vector3 _originPos, Vector3 _targetPos)
{
PolygonCollider2D poly = KickStarter.sceneSettings.navMesh.transform.GetComponent <PolygonCollider2D>();
bool changesMade = KickStarter.sceneSettings.navMesh.AddCharHoles(_char);
List <Vector3> pointsList3D = new List <Vector3> ();
if (IsLineClear(_originPos, _targetPos))
{
pointsList3D.Add(_targetPos);
//ResetHoles (KickStarter.sceneSettings.navMesh, changesMade);
return(pointsList3D.ToArray());
}
Vector2[] pointsList = CreateVertexArray(poly);
Vector2 originPos = GetNearestToMesh(_originPos, poly);
Vector2 targetPos = GetNearestToMesh(_targetPos, poly);
pointsList = AddEndsToList(pointsList, originPos, targetPos);
float[,] weight = pointsToWeight(pointsList);
int[] precede = buildSpanningTree(0, 1, weight);
if (precede == null)
{
Debug.LogWarning("Pathfinding error");
pointsList3D.Add(_targetPos);
return(pointsList3D.ToArray());
}
int[] _path = getShortestPath(0, 1, precede);
foreach (int i in _path)
{
Vector3 vertex = new Vector3(pointsList[i].x, pointsList[i].y, _originPos.z);
pointsList3D.Insert(0, vertex);
}
if (pointsList3D[0] == _originPos || (pointsList3D[0].x == originPos.x && pointsList3D[0].y == originPos.y))
{
pointsList3D.RemoveAt(0); // Remove origin point from start
}
ResetHoles(KickStarter.sceneSettings.navMesh, changesMade);
return(pointsList3D.ToArray());
}
public static void Play(Char speaker, string speakerName, int lineNumber, string language)
{
if (speaker == null)
{
return;
}
#if RogoLipSyncIsPresent
if (lineNumber > -1 && speakerName != "" && KickStarter.speechManager.searchAudioFiles)
{
string filename = "Lipsync/";
if (KickStarter.speechManager.placeAudioInSubfolders)
{
filename += speakerName + "/";
}
if (language != "" && KickStarter.speechManager.translateAudio)
{
// Not in original language
filename += language + "/";
}
filename += speakerName + lineNumber;
RogoDigital.Lipsync.LipSyncData lipSyncData = Resources.Load (filename) as RogoDigital.Lipsync.LipSyncData;
if (lipSyncData != null)
{
if (speaker.GetComponent <RogoDigital.Lipsync.LipSync>() != null)
{
speaker.GetComponent <RogoDigital.Lipsync.LipSync>().Play (lipSyncData);
}
else
{
ACDebug.LogWarning ("No LipSync component found on " + speaker.gameObject.name + " gameobject.");
}
}
else
{
ACDebug.LogWarning ("No lipsync file found. Looking for 'Resources/" + filename + "'");
}
}
#else
ACDebug.LogError ("The 'RogoLipSyncIsPresent' preprocessor define must be declared in the Player Settings.");
#endif
}
/**
* <summary>Assigns a new target (NPC or Player) to start following.</summary>
* <param name = "_followTarget">The target to follow</param>
* <param name = "_followTargetIsPlayer">If True, the NPC will follow the current Player, and _followTarget will be ignored</param>
* <param name = "_followFrequency">The frequency with which to follow the target</param>
* <param name = "_followDistance">The minimum distance to keep from the target</param>
* <param name = "_followDistanceMax">The maximum distance to keep from the target</param>
*/
public void FollowAssign(Char _followTarget, bool _followTargetIsPlayer, float _followFrequency, float _followDistance, float _followDistanceMax)
{
if (_followTargetIsPlayer)
{
_followTarget = KickStarter.player;
}
if (_followTarget == null || _followFrequency == 0f || _followFrequency < 0f || _followDistance <= 0f || _followDistanceMax <= 0f)
{
StopFollowing ();
return;
}
followTarget = _followTarget;
followTargetIsPlayer = _followTargetIsPlayer;
followFrequency = _followFrequency;
followDistance = _followDistance;
followDistanceMax = _followDistanceMax;
FollowUpdate ();
}
protected void SharedGUIOne(AC.Char _target)
{
if (_target.animEngine == null || !_target.animEngine.ToString().Contains(_target.animationEngine.ToString()))
{
_target.ResetAnimationEngine();
}
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Animation settings:", EditorStyles.boldLabel);
_target.animationEngine = (AnimationEngine)EditorGUILayout.EnumPopup("Animation engine:", _target.animationEngine);
if (_target.animationEngine == AnimationEngine.Sprites2DToolkit && !tk2DIntegration.IsDefinePresent())
{
EditorGUILayout.HelpBox("The 'tk2DIsPresent' preprocessor define must be declared in the\ntk2DIntegration.cs script. Please open it and follow instructions.", MessageType.Warning);
}
if (_target.animationEngine == AnimationEngine.Custom)
{
_target.customAnimationClass = EditorGUILayout.TextField("Script name:", _target.customAnimationClass);
_target.motionControl = (MotionControl)EditorGUILayout.EnumPopup("Motion control:", _target.motionControl);
}
EditorGUILayout.EndVertical();
_target.animEngine.CharSettingsGUI();
EditorGUILayout.BeginVertical("Button");
EditorGUILayout.LabelField("Movement settings:", EditorStyles.boldLabel);
if (_target.GetMotionControl() == MotionControl.Automatic)
{
_target.walkSpeedScale = EditorGUILayout.FloatField("Walk speed scale:", _target.walkSpeedScale);
_target.runSpeedScale = EditorGUILayout.FloatField("Run speed scale:", _target.runSpeedScale);
_target.acceleration = EditorGUILayout.FloatField("Acceleration:", _target.acceleration);
_target.deceleration = EditorGUILayout.FloatField("Deceleration:", _target.deceleration);
}
if (_target.GetMotionControl() != MotionControl.Manual)
{
_target.turnSpeed = EditorGUILayout.FloatField("Turn speed:", _target.turnSpeed);
}
_target.turnBeforeWalking = EditorGUILayout.Toggle("Turn before walking?", _target.turnBeforeWalking);
EditorGUILayout.EndVertical();
}
override public void ShowGUI (List<ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle ("Affect Player?", isPlayer);
if (!isPlayer)
{
charToMoveParameterID = Action.ChooseParameterGUI ("Character to turn:", parameters, charToMoveParameterID, ParameterType.GameObject);
if (charToMoveParameterID >= 0)
{
charToMoveID = 0;
charToMove = null;
}
else
{
charToMove = (Char) EditorGUILayout.ObjectField ("Character to turn:", charToMove, typeof(Char), true);
charToMoveID = FieldToID <Char> (charToMove, charToMoveID);
charToMove = IDToField <Char> (charToMove, charToMoveID, false);
}
facePlayer = EditorGUILayout.Toggle ("Face player?", facePlayer);
}
else
{
facePlayer = false;
SettingsManager settingsManager = AdvGame.GetReferences ().settingsManager;
if (faceType == CharFaceType.Body && settingsManager && settingsManager.IsInFirstPerson ())
{
lookUpDown = EditorGUILayout.Toggle ("FPS head tilt?", lookUpDown);
}
}
faceType = (CharFaceType) EditorGUILayout.EnumPopup ("Face with:", faceType);
if (faceType == CharFaceType.Head)
{
stopLooking = EditorGUILayout.Toggle ("Stop looking?", stopLooking);
}
if (facePlayer || (faceType == CharFaceType.Head && stopLooking))
{ }
else
{
faceObjectParameterID = Action.ChooseParameterGUI ("Object to face:", parameters, faceObjectParameterID, ParameterType.GameObject);
if (faceObjectParameterID >= 0)
{
faceObjectID = 0;
faceObject = null;
}
else
{
faceObject = (GameObject) EditorGUILayout.ObjectField ("Object to face:", faceObject, typeof(GameObject), true);
faceObjectID = FieldToID (faceObject, faceObjectID);
faceObject = IDToField (faceObject, faceObjectID, false);
}
}
if (faceType == CharFaceType.Body)
{
copyRotation = EditorGUILayout.Toggle ("Use object's rotation?", copyRotation);
}
isInstant = EditorGUILayout.Toggle ("Is instant?", isInstant);
if (!isInstant)
{
willWait = EditorGUILayout.Toggle ("Wait until finish?", willWait);
}
AfterRunningOption ();
}
public virtual Vector3[] GetPointsArray(AC.Char _char, Vector3 startPosition, Vector3 targetPosition)
{
return(GetPointsArray(startPosition, targetPosition));
}
/**
* <summary>Checks if a given character is speaking.</summary>
* <param name = "_char".The character to check</param>
* <returns>True if the character is speaking</returns>
*/
public bool CharacterIsSpeaking(Char _char)
{
foreach (Speech speech in speechList)
{
if (speech.GetSpeakingCharacter () == _char)
{
return true;
}
}
return false;
}
override public void ShowGUI (List<ActionParameter> parameters)
{
if (lineID > -1)
{
EditorGUILayout.LabelField ("Speech Manager ID:", lineID.ToString ());
}
isPlayer = EditorGUILayout.Toggle ("Player line?",isPlayer);
if (isPlayer)
{
if (Application.isPlaying)
{
speaker = KickStarter.player;
}
else
{
speaker = AdvGame.GetReferences ().settingsManager.GetDefaultPlayer ();
}
}
else
{
parameterID = Action.ChooseParameterGUI ("Speaker:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
speaker = null;
}
else
{
speaker = (Char) EditorGUILayout.ObjectField ("Speaker:", speaker, typeof(Char), true);
constantID = FieldToID <Char> (speaker, constantID);
speaker = IDToField <Char> (speaker, constantID, false);
}
}
EditorGUILayout.LabelField ("Line text:", GUILayout.Width (145f));
EditorStyles.textField.wordWrap = true;
messageText = EditorGUILayout.TextArea (messageText);
if (speaker)
{
if (speaker.animEngine == null)
{
speaker.ResetAnimationEngine ();
}
if (speaker.animEngine)
{
speaker.animEngine.ActionSpeechGUI (this);
}
}
else
{
EditorGUILayout.HelpBox ("If no Character is set, this line will be considered to be a Narration.", MessageType.Info);
}
isBackground = EditorGUILayout.Toggle ("Play in background?", isBackground);
if (!isBackground)
{
waitTimeOffset = EditorGUILayout.Slider ("Wait time offset (s):", waitTimeOffset, -1f, 4f);
}
AfterRunningOption ();
}
public override bool AddCharHoles(PolygonCollider2D navPoly, Char charToExclude)
{
if (navPoly == null) return false;
bool changesMade = false;
Vector2 navPosition = navPoly.transform.position;
AC.Char[] characters = GameObject.FindObjectsOfType (typeof (AC.Char)) as AC.Char[];
foreach (AC.Char character in characters)
{
CircleCollider2D circleCollider2D = character.GetComponent <CircleCollider2D>();
if (circleCollider2D != null && character.charState == CharState.Idle
&& (charToExclude == null || character != charToExclude)
&& Physics2D.OverlapPointNonAlloc (character.transform.position, NavigationEngine_PolygonCollider.results, 1 << KickStarter.sceneSettings.navMesh.gameObject.layer) != 0)
{
circleCollider2D.isTrigger = true;
List<Vector2> newPoints3D = new List<Vector2>();
#if UNITY_5
Vector2 centrePoint = character.transform.TransformPoint (circleCollider2D.offset);
#else
Vector2 centrePoint = character.transform.TransformPoint (circleCollider2D.center);
#endif
float radius = circleCollider2D.radius * character.transform.localScale.x;
newPoints3D.Add (centrePoint + Vector2.up * radius);
newPoints3D.Add (centrePoint + Vector2.right * radius);
newPoints3D.Add (centrePoint - Vector2.up * radius);
newPoints3D.Add (centrePoint - Vector2.right * radius);
navPoly.pathCount ++;
List<Vector2> newPoints = new List<Vector2>();
for (int i=0; i<newPoints3D.Count; i++)
{
// Only add a point if it is on the NavMesh
if (Physics2D.OverlapPointNonAlloc (newPoints3D[i], NavigationEngine_PolygonCollider.results, 1 << KickStarter.sceneSettings.navMesh.gameObject.layer) != 0)
{
newPoints.Add (newPoints3D[i] - navPosition);
}
else
{
Vector2 altPoint = GetLineIntersect (newPoints3D[i], centrePoint);
if (altPoint != Vector2.zero)
{
newPoints.Add (altPoint - navPosition);
}
}
}
if (newPoints.Count > 1)
{
navPoly.SetPath (navPoly.pathCount-1, newPoints.ToArray ());
changesMade = true;
}
}
}
return changesMade;
}
public override void ShowGUI(List<ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle ("Player line?",isPlayer);
if (isPlayer)
{
if (Application.isPlaying)
{
speaker = KickStarter.player;
}
else
{
speaker = AdvGame.GetReferences ().settingsManager.GetDefaultPlayer ();
}
}
else
{
parameterID = Action.ChooseParameterGUI ("Speaker:", parameters, parameterID, ParameterType.GameObject);
if (parameterID >= 0)
{
constantID = 0;
speaker = null;
}
else
{
speaker = (Char) EditorGUILayout.ObjectField ("Speaker:", speaker, typeof(Char), true);
constantID = FieldToID <Char> (speaker, constantID);
speaker = IDToField <Char> (speaker, constantID, false);
}
}
AfterRunningOption ();
}
public void SetSpeaker()
{
if (!isPlayer && parameterID == -1)
{
speaker = IDToField <Char> (speaker, constantID, false);
}
}
public virtual void ActionSpeechGUI(ActionSpeech action, Char speaker)
{
#if UNITY_EDITOR
#endif
}
public override void ShowGUI(List<ActionParameter> parameters)
{
npcToMoveParameterID = Action.ChooseParameterGUI ("NPC to affect:", parameters, npcToMoveParameterID, ParameterType.GameObject);
if (npcToMoveParameterID >= 0)
{
npcToMoveID = 0;
npcToMove = null;
}
else
{
npcToMove = (NPC) EditorGUILayout.ObjectField ("NPC to affect:", npcToMove, typeof(NPC), true);
npcToMoveID = FieldToID <NPC> (npcToMove, npcToMoveID);
npcToMove = IDToField <NPC> (npcToMove, npcToMoveID, false);
}
followType = (FollowType) EditorGUILayout.EnumPopup ("Follow type:", followType);
if (followType == FollowType.StartFollowing)
{
followPlayer = EditorGUILayout.Toggle ("Follow Player?", followPlayer);
if (!followPlayer)
{
charToFollowParameterID = Action.ChooseParameterGUI ("Character to follow:", parameters, charToFollowParameterID, ParameterType.GameObject);
if (charToFollowParameterID >= 0)
{
charToFollowID = 0;
charToFollow = null;
}
else
{
charToFollow = (Char) EditorGUILayout.ObjectField ("Character to follow:", charToFollow, typeof(Char), true);
if (charToFollow && charToFollow == (Char) npcToMove)
{
charToFollow = null;
Debug.LogWarning ("An NPC cannot follow themselves!");
}
else
{
charToFollowID = FieldToID <Char> (charToFollow, charToFollowID);
charToFollow = IDToField <Char> (charToFollow, charToFollowID, false);
}
}
}
updateFrequency = EditorGUILayout.FloatField ("Update frequency (s):", updateFrequency);
if (updateFrequency == 0f || updateFrequency < 0f)
{
EditorGUILayout.HelpBox ("Update frequency must be greater than zero.", MessageType.Warning);
}
followDistance = EditorGUILayout.FloatField ("Minimum distance:", followDistance);
if (followDistance <= 0f)
{
EditorGUILayout.HelpBox ("Minimum distance must be greater than zero.", MessageType.Warning);
}
followDistanceMax = EditorGUILayout.FloatField ("Maximum distance:", followDistanceMax);
if (followDistanceMax <= 0f || followDistanceMax < followDistance)
{
EditorGUILayout.HelpBox ("Maximum distance must be greater than minimum distance.", MessageType.Warning);
}
}
AfterRunningOption ();
}
override public void ShowGUI (List<ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle ("Is Player?", isPlayer);
if (!isPlayer)
{
charToMoveParameterID = Action.ChooseParameterGUI ("Character to move:", parameters, charToMoveParameterID, ParameterType.GameObject);
if (charToMoveParameterID >= 0)
{
charToMoveID = 0;
charToMove = null;
}
else
{
charToMove = (Char) EditorGUILayout.ObjectField ("Character to move:", charToMove, typeof (Char), true);
charToMoveID = FieldToID <Char> (charToMove, charToMoveID);
charToMove = IDToField <Char> (charToMove, charToMoveID, false);
}
}
markerParameterID = Action.ChooseParameterGUI ("Marker to reach:", parameters, markerParameterID, ParameterType.GameObject);
if (markerParameterID >= 0)
{
markerID = 0;
marker = null;
}
else
{
marker = (Marker) EditorGUILayout.ObjectField ("Marker to reach:", marker, typeof (Marker), true);
markerID = FieldToID <Marker> (marker, markerID);
marker = IDToField <Marker> (marker, markerID, false);
}
speed = (PathSpeed) EditorGUILayout.EnumPopup ("Move speed:" , speed);
pathFind = EditorGUILayout.Toggle ("Pathfind?", pathFind);
if (!pathFind)
{
doFloat = EditorGUILayout.Toggle ("Ignore gravity?", doFloat);
}
willWait = EditorGUILayout.Toggle ("Wait until finish?", willWait);
AfterRunningOption ();
}
public override void AssignValues(List<ActionParameter> parameters)
{
npcToMove = AssignFile <NPC> (parameters, npcToMoveParameterID, npcToMoveID, npcToMove);
charToFollow = AssignFile <Char> (parameters, charToFollowParameterID, charToFollowID, charToFollow);
}
public void Start()
{
// Get and validate the arguments:
if (!DialogueManager.IsConversationActive)
{
if (DialogueDebug.LogWarnings)
{
Debug.LogWarning(string.Format("{0}: Sequencer command ACSpeech({1}): No conversation is active; can't run", DialogueDebug.Prefix, GetParameters()));
}
return;
}
var subtitle = DialogueManager.CurrentConversationState.subtitle;
if (subtitle == null)
{
if (DialogueDebug.LogWarnings)
{
Debug.LogWarning(string.Format("{0}: Sequencer command ACSpeech({1}): The subtitle record is invalid", DialogueDebug.Prefix, GetParameters()));
}
return;
}
if (string.IsNullOrEmpty(subtitle.dialogueEntry.DialogueText) && string.Equals(subtitle.dialogueEntry.Title, "START"))
{
return;
}
var subject = (subtitle.speakerInfo == null) ? null : subtitle.speakerInfo.transform;
speakerChar = (subject == null) ? null : subject.GetComponent <AC.Char>();
if (speakerChar == null)
{
foreach (var character in FindObjectsOfType <AC.Char>())
{
if (string.Equals(character.name, subtitle.speakerInfo.Name))
{
speakerChar = character;
break;
}
}
}
if (speakerChar == null)
{
if (DialogueDebug.LogWarnings)
{
Debug.LogWarning(string.Format("{0}: Sequencer command ACSpeech({1}): Speaker character not found", DialogueDebug.Prefix, GetParameters()));
}
return;
}
var speakerName = speakerChar.name;
var isPlayer = (speakerChar.GetComponent <Player>() != null);
if (isPlayer)
{
speakerChar = KickStarter.player;
if ((KickStarter.settingsManager.playerSwitching == PlayerSwitching.Allow || !KickStarter.speechManager.usePlayerRealName))
{
speakerName = "Player";
}
}
var text = subtitle.formattedText.text;
var lineID = GetParameter(0);
var numberString = lineID.Substring(Mathf.Min(lineID.Length, speakerName.Length));
var lineNumber = Tools.StringToInt(numberString);
//--- No longer used: var language = Options.GetLanguageName();
var isBackground = string.Equals(GetParameter(1), "nowait", System.StringComparison.OrdinalIgnoreCase);
var noAnimation = false;
Debug.Log(string.Format("{0}: Sequencer command ACSpeech({1}): speaker={2}, lineNumber={3}, text='{4}', isBackground={5}, isPlayer={6}",
DialogueDebug.Prefix, GetParameters(), speakerName, lineNumber, text, isBackground, isPlayer));
// Hook into AC's EventManager to be notified when speech stops:
AC.EventManager.OnStopSpeech += OnStopSpeech;
// Call AC's speech functionality. Credit: Based on AC's ActionSpeech.cs (c) Icebox Studios.
KickStarter.dialog.KillDialog(false, true);
KickStarter.dialog.StartDialog(speakerChar, text, isBackground, lineNumber, noAnimation);
}
private void OnStopSpeech(AC.Char speakingCharacter)
{
Stop();
}
/**
* <summary>Initialises a new Speech line.</summary>
* <param name = "_speaker">The speaking character. If null, the line will be treated as narration</param>
* <param name = "_text">The subtitle text to display</param>
* <param name = "isBackground">True if the line should play in the background, and not interrupt any Actions or gameplay</param>
* <param name = "lineID">The ID number of the line, if it is listed in the Speech Manager</param>
* <param name = "noAnimation">True if the character should not play a talking animation</param>
* <returns>The generated Speech line</returns>
*/
public Speech StartDialog(Char _speaker, string _text, bool isBackground = false, int lineID = -1, bool noAnimation = false)
{
// Get the language
string _language = "";
int lanuageNumber = Options.GetLanguage ();
if (lanuageNumber > 0)
{
// Not in original language, so pull translation in from Speech Manager
_language = KickStarter.speechManager.languages [lanuageNumber];
}
// Remove speaker's previous line
for (int i=0; i<speechList.Count; i++)
{
if (speechList[i].GetSpeakingCharacter () == _speaker)
{
EndSpeech (i);
i=0;
}
}
Speech speech = new Speech (_speaker, _text, lineID, _language, isBackground, noAnimation);
speechList.Add (speech);
KickStarter.runtimeVariables.AddToSpeechLog (speech.log);
KickStarter.playerMenus.AssignSpeechToMenu (speech);
if (speech.hasAudio)
{
if (KickStarter.speechManager.relegateBackgroundSpeechAudio)
{
EndBackgroundSpeechAudio (speech);
}
KickStarter.stateHandler.UpdateAllMaxVolumes ();
}
return speech;
}
public override void ShowGUI(List<ActionParameter> parameters)
{
isPlayer = EditorGUILayout.Toggle ("Is Player?", isPlayer);
if (isPlayer)
{
if (Application.isPlaying)
{
_char = KickStarter.player;
}
else if (AdvGame.GetReferences ().settingsManager)
{
_char = AdvGame.GetReferences ().settingsManager.GetDefaultPlayer ();
}
else
{
EditorGUILayout.HelpBox ("A Settings Manager and player must be defined", MessageType.Warning);
}
}
else
{
_char = (Char) EditorGUILayout.ObjectField ("Character:", _char, typeof (Char), true);
_charID = FieldToID <Char> (_char, _charID);
_char = IDToField <Char> (_char, _charID, true);
}
if (_char)
{
if (_char.GetAnimEngine () && _char.GetAnimEngine ().ActionCharHoldPossible ())
{
objectToHoldParameterID = Action.ChooseParameterGUI ("Object to hold:", parameters, objectToHoldParameterID, ParameterType.GameObject);
if (objectToHoldParameterID >= 0)
{
objectToHoldID = 0;
objectToHold = null;
}
else
{
objectToHold = (GameObject) EditorGUILayout.ObjectField ("Object to hold:", objectToHold, typeof (GameObject), true);
objectToHoldID = FieldToID (objectToHold, objectToHoldID);
objectToHold = IDToField (objectToHold, objectToHoldID, false);
}
hand = (Hand) EditorGUILayout.EnumPopup ("Hand:", hand);
rotate90 = EditorGUILayout.Toggle ("Rotate 90 degrees?", rotate90);
}
else
{
EditorGUILayout.HelpBox ("This Action is not compatible with this Character's Animation Engine.", MessageType.Info);
}
}
else
{
EditorGUILayout.HelpBox ("This Action requires a Character before more options will show.", MessageType.Info);
}
AfterRunningOption ();
}
public Speech StartDialog(Char _speaker, string _text, int lineID, string _language, bool isBackground, bool noAnimation)
{
// Remove speaker's previous line
for (int i=0; i<speechList.Count; i++)
{
if (speechList[i].GetSpeakingCharacter () == _speaker)
{
EndSpeech (i);
i=0;
}
}
Speech speech = new Speech (_speaker, _text, lineID, _language, isBackground, noAnimation);
speechList.Add (speech);
KickStarter.runtimeVariables.AddToSpeechLog (speech.log);
KickStarter.playerMenus.AssignSpeechToMenu (speech);
if (speech.hasAudio)
{
if (KickStarter.speechManager.relegateBackgroundSpeechAudio)
{
EndBackgroundSpeechAudio (speech);
}
KickStarter.stateHandler.UpdateAllMaxVolumes ();
}
return speech;
}
public override void Declare(AC.Char _character)
{
character = _character;
turningStyle = TurningStyle.RootMotion;
rootMotion = true;
}
private void Start()
{
/*
* First, we'll assign our private variables, and give warnings if things are not as expected.
*/
navMeshAgent = GetComponent <NavMeshAgent>();
originalSpeed = navMeshAgent.speed;
_char = GetComponent <AC.Char>();
if (_char == null)
{
ACDebug.LogWarning ("A 'Player' or 'NPC' component must be attached to " + gameObject.name + " for the NavMeshAgentIntegration script to work.", gameObject);
}
else
{
SetMotionControl ();
/*
* Get the player's initial position, based on the appropriate PlayerStart
*/
if (KickStarter.sceneSettings && KickStarter.sceneSettings.GetPlayerStart ())
{
targetPosition = KickStarter.sceneSettings.GetPlayerStart ().transform.position;
}
/*
* If this controls a Player, and the game's Movement method is not Point And Click,
* we'll allow regular AC control over movement during gameplay.
*/
if (_char is Player && KickStarter.settingsManager != null && KickStarter.settingsManager.movementMethod != MovementMethod.PointAndClick)
{
disableDuringGameplay = true;
}
}
if (KickStarter.sceneSettings != null && KickStarter.sceneSettings.navigationMethod != AC_NavigationMethod.UnityNavigation)
{
ACDebug.LogWarning ("For the NavMeshAgentIntegration script to work, your scene's pathfinding method must be set to 'Unity Navigation'");
}
}
public override void ShowGUI(List<ActionParameter> parameters)
{
UpgradeSelf ();
isPlayer = EditorGUILayout.Toggle ("Is Player?", isPlayer);
if (!isPlayer)
{
charToMoveParameterID = Action.ChooseParameterGUI ("Character to move:", parameters, charToMoveParameterID, ParameterType.GameObject);
if (charToMoveParameterID >= 0)
{
charToMoveID = 0;
charToMove = null;
}
else
{
charToMove = (Char) EditorGUILayout.ObjectField ("Character to move:", charToMove, typeof (Char), true);
charToMoveID = FieldToID <Char> (charToMove, charToMoveID);
charToMove = IDToField <Char> (charToMove, charToMoveID, false);
}
}
movePathMethod = (MovePathMethod) EditorGUILayout.EnumPopup ("Method:", movePathMethod);
if (movePathMethod == MovePathMethod.MoveOnNewPath)
{
movePathParameterID = Action.ChooseParameterGUI ("Path to follow:", parameters, movePathParameterID, ParameterType.GameObject);
if (movePathParameterID >= 0)
{
movePathID = 0;
movePath = null;
}
else
{
movePath = (Paths) EditorGUILayout.ObjectField ("Path to follow:", movePath, typeof(Paths), true);
movePathID = FieldToID <Paths> (movePath, movePathID);
movePath = IDToField <Paths> (movePath, movePathID, false);
}
doTeleport = EditorGUILayout.Toggle ("Teleport to start?", doTeleport);
if (movePath != null && movePath.pathType != AC_PathType.ForwardOnly)
{
willWait = false;
}
else
{
willWait = EditorGUILayout.Toggle ("Wait until finish?", willWait);
}
if (movePath != null && movePath.GetComponent <Char>())
{
EditorGUILayout.HelpBox ("Can't follow a Path attached to a Character!", MessageType.Warning);
}
}
else if (movePathMethod == MovePathMethod.ResumeLastSetPath)
{
//
}
AfterRunningOption ();
}