IEnumerator InitPlayer()
{
StatusText.text = "Done!";
yield return(new WaitForSeconds(2.0f));
PC = Instantiate(PlayerCharacter).GetComponent <PlayerController>();
PC.GetComponent <PlayerController>().map = Generator;
List <int> usedPositions = new List <int>();
foreach (FriendController FriendCharacter in Friends)
{
int len = Generator.IslandStart.Length;
FriendController FC = Instantiate(FriendCharacter).GetComponent <FriendController>();
int randIdx = UnityEngine.Random.Range(0, len);
while (usedPositions.Contains(randIdx))
{
randIdx = UnityEngine.Random.Range(0, len);
}
usedPositions.Add(randIdx);
FC.transform.position = Generator.IslandStart[randIdx];
}
FollowPlayer fp = Camera.main.GetComponent <FollowPlayer>();
fp.shouldFit = false;
fp.player = PC.transform;
fp.UpdatePosition(new Vector3(-8.05f, 14.53f, -7.85f));
}
public FriendControllerTests()
{
_friendService = new FriendServiceStub();
_borrowService = new BorrowServiceStub();
_reviewService = new ReviewServiceStub();
_controller = new FriendController(_friendService, _reviewService, _borrowService);
}
private void button2_Click(object sender, EventArgs e)
{
FriendController = new FriendController(flowLayoutPanel1);
button5.Text = "Підписники " + FriendController.GetCountFollowers();
button6.Text = "Друзі " + FriendController.GetCountFriends();
tabControl1.SelectTab(tabPage2);
}
public void GetFriendById()
{
// Arrange
friendRepository.Setup(x => x.GetFriendById(1)).Returns(getFriend);
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary {
{ "controller", "friend" }
});
var controller = new FriendController(friendRepository.Object)
{
Request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:1175/api/Friend/FriendId?friendId={friendId}")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
// Act
var response = controller.GetFriendById(1);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
void OnTriggerEnter(Collider other)
{
if (other.GetComponent <RespawnOnFall>() != null)
{
other.GetComponent <RespawnOnFall>().Respawn();
return;
}
if (other.tag == "Player")
{
FriendController f = other.GetComponent <FriendController>();
RoundManager.instance.TriggerPlayerDeath(f.playerNum);
if (!GameManager.instance.gameRunning)
{
f.Respawn();
}
else if (RoundManager.settings.playerRespawn)
{
f.Respawn();
}
else
{
RoundManager.instance.playersToRespawn.Add(f);
}
}
}
public BorrowingMenu(BorrowingController controllerBorrowing, FriendController controllerFriend, MagazineController controllerMagazine, ConsoleColor fontColor)
{
this.mainController = controllerBorrowing;
this.controllerFriend = controllerFriend;
this.controllerMagazine = controllerMagazine;
this.fontColor = fontColor;
}
public async void RemoveFriendRequestRoute_Test()
{
// Arrange
var user = CreatePerson();
var friend = CreatePerson();
var acceptedFriends = new List <Person>();
_personRepository
.Setup(x => x.Single(p => p.Name == user.Name))
.ReturnsAsync(user);
_personRepository
.Setup(x => x.Single(p => p.Name == friend.Name))
.ReturnsAsync(friend);
_friendRepository
.Setup(x =>
x.DeleteFriendsWithRelationshipAsync(
It.IsAny <Person>(),
It.IsAny <Person>()))
.Verifiable();
var personController = new PersonController(_personRepository.Object, _mapper, _emailHelper.Object, _tokenClass.Object);
var friendController = new FriendController(_personRepository.Object, _friendRepository.Object, _mapper);
// Act
var result = await friendController.RemoveFriend(user.Name, friend.Name);
var okResult = result as OkObjectResult;
// Assert
Assert.True(okResult != null);
Assert.Equal(200, okResult.StatusCode);
}
public void CreateFriend()
{
// Arrange
friendRepository.Setup(c => c.Insert(It.IsAny <Friend>())).Returns(true);
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary {
{ "controller", "friend" }
});
var controller = new FriendController(friendRepository.Object)
{
Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:1175/api/Friend/CreateFriend")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
// Act
var response = controller.CreateFriend(postFriend);
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
public MainMenu(ConsoleColor fontColor)
{
controllerFriend = new FriendController();
controllerStorageBox = new StorageBoxController();
controllerMagazine = new MagazineController();
controllerBorrowing = new BorrowingController();
this.fontColor = fontColor;
}
public void SetUp()
{
_unitOfWork = new Mock <IUnitOfWork>();
_friendService = new Mock <IFriendService>();
_userService = new Mock <IUserService>();
_notificationService = new Mock <INotificationService>();
_friendController = new FriendController(_friendService.Object, _userService.Object, _unitOfWork.Object, _notificationService.Object);
}
public void FindClosestFriendsTest()
{
var retorno = new FriendController(_mapper, _friendRepository, _locationService)
.FindClosestFriends(new LocationModel()
{
Latitude = 0.0, Longitude = 0.0
});
Assert.IsInstanceOfType(retorno.Result, typeof(OkObjectResult));
}
public void Test_Add_Distant_Friend()
{
var targetSession = TestHelpers.Instance.GenerateSession();
var friendRequestHolder = new FriendRequestHolder();
friendRequestHolder.FriendRequestCharacters.TryAdd(Guid.NewGuid(),
new Tuple <long, long>(targetSession.Character.CharacterId, _session.Character.CharacterId));
var flPacket = new FlPacket
{
CharacterName = targetSession.Character.Name
};
TestHelpers.Instance.ConnectedAccountHttpClient
.Setup(s => s.GetCharacter(targetSession.Character.CharacterId, null))
.Returns((new ServerConfiguration(),
new ConnectedAccount
{
ChannelId = 1, ConnectedCharacter = new Character {
Id = targetSession.Character.CharacterId
}
}));
TestHelpers.Instance.ConnectedAccountHttpClient
.Setup(s => s.GetCharacter(_session.Character.CharacterId, null))
.Returns((new ServerConfiguration(),
new ConnectedAccount
{
ChannelId = 1, ConnectedCharacter = new Character {
Id = _session.Character.CharacterId
}
}));
using var friend = new FriendController(_logger, _characterRelationDao, TestHelpers.Instance.CharacterDao,
friendRequestHolder, TestHelpers.Instance.ConnectedAccountHttpClient.Object);
TestHelpers.Instance.FriendHttpClient.Setup(s => s.AddFriend(It.IsAny <FriendShipRequest>()))
.Returns(friend.AddFriend(new FriendShipRequest
{
CharacterId = _session.Character.CharacterId,
FinsPacket = new FinsPacket
{
CharacterId = targetSession.Character.VisualId,
Type = FinsPacketType.Accepted
}
}));
_flPacketHandler.Execute(flPacket, _session);
Assert.IsTrue(_characterRelationDao.FirstOrDefault(s =>
(s.CharacterId == _session.Character.CharacterId) &&
(s.RelatedCharacterId == targetSession.Character.CharacterId) &&
(s.RelationType == CharacterRelationType.Friend)) != null);
}
public new void Awake()
{
base.Awake();
if (target == null)
{
return;
}
cagedPlayer = target.GetComponent <FriendController>();
ResetTargetPos();
interactionMenu.AddMenuOption(InteractionType.PLAYER, new InteractableMenu.MenuOption("Open", interaction => Open(interaction)));
}
IEnumerator AwardPoints()
{
for (int i = 0; i < 20; i++)
{
if (potato.transform.parent != null && potato.transform.parent.parent != null)
{
FriendController f = potato.transform.parent.parent.GetComponent <FriendController>();
if (f != null)
{
GameManager.ChangeScore(f.playerNum, 1);
}
}
yield return(new WaitForSeconds(1f));
}
}
public void Setup()
{
_characterRelationDao = new GenericDao <CharacterRelation, CharacterRelationDto, Guid>(_logger);
Broadcaster.Reset();
TestHelpers.Reset();
_session = TestHelpers.Instance.GenerateSession();
_channelHttpClient = TestHelpers.Instance.ChannelHttpClient;
_connectedAccountHttpClient = TestHelpers.Instance.ConnectedAccountHttpClient;
_friendHttpClient = TestHelpers.Instance.FriendHttpClient;
_fDelPacketHandler = new FdelPacketHandler(_friendHttpClient.Object, _channelHttpClient.Object,
_connectedAccountHttpClient.Object);
_characterDao = new Mock <IGenericDao <CharacterDto> >();
_friendController = new FriendController(_logger, _characterRelationDao, _characterDao.Object,
new FriendRequestHolder(), _connectedAccountHttpClient.Object);
_friendHttpClient.Setup(s => s.GetListFriends(It.IsAny <long>()))
.Returns((long id) => _friendController.GetFriends(id));
_friendHttpClient.Setup(s => s.DeleteFriend(It.IsAny <Guid>()))
.Callback((Guid id) => _friendController.Delete(id));
}
public void Test_Add_Not_Requested_Friend()
{
var finsPacket = new FinsPacket
{
CharacterId = _targetSession.Character.CharacterId,
Type = FinsPacketType.Accepted
};
using var friend = new FriendController(_logger, _characterRelationDao, TestHelpers.Instance.CharacterDao,
_friendRequestHolder, _connectedAccountHttpClient.Object);
_friendHttpClient.Setup(s => s.AddFriend(It.IsAny <FriendShipRequest>()))
.Returns(friend.AddFriend(new FriendShipRequest
{
CharacterId = _session.Character.CharacterId, FinsPacket = finsPacket
}));
_finsPacketHandler.Execute(finsPacket, _session);
Assert.IsFalse(_characterRelationDao.LoadAll().Any());
}
/// <summary>
/// 初始化
/// </summary>
public void Initialize()
{
m_SocketClient = new SocketClient();
m_SendWriter = new BinaryWriter(new MemoryStream(DEFAULT_SEND_BUFFER_SIZE));
m_NetControllers = new BetterList <BaseNetController>();
m_GatewayProtocolMapping = new ProtocolMapping();
m_GameServerProtocolMapping = new ProtocolMapping();
m_SendToGameServerWriter = new BinaryWriter(new MemoryStream(DEFAULT_SEND_BUFFER_SIZE));
m_PlayerToGSProto = SingleInstanceCache.GetInstanceByType <KC2G_PlayerToGS>();
m_Handshake = false;
m_MessageToken = "";
m_MessageTokenHash = 0;
m_MessageIndex = 0;
ListenGateway(KG2C_Protocol.g2c_gs_to_player, OnReceivedGameServerMessage, typeof(KG2C_GSToPlayer));
#region NetController
m_LoginController = new LoginController();
m_CharacterListController = new CharacterListController();
m_SceneController = new SceneController();
m_PlayerController = new PlayerController();
m_MailController = new MailController();
m_LogController = new LogController();
m_FriendController = new FriendController();
m_TeamController = new TeamController();
m_PackageController = new PackageController();
m_ShopController = new ShopController();
m_FoundryController = new FoundryController();
m_InstanceController = new InstanceController();
m_MissionController = new MissionController();
m_ChatContoller = new Game.Frame.Net.ChatController();
m_SkillController = new SkillController();
m_DropItemController = new DropItemController();
m_reliveController = new ReliveController();
m_MSAIBossController = new MSAIBossController();
#endregion
}
public void Test_Add_Friend()
{
_friendRequestHolder.FriendRequestCharacters.TryAdd(Guid.NewGuid(),
new Tuple <long, long>(_targetSession.Character.CharacterId, _session.Character.CharacterId));
var finsPacket = new FinsPacket
{
CharacterId = _targetSession.Character.CharacterId,
Type = FinsPacketType.Accepted
};
using var friend = new FriendController(_logger, _characterRelationDao, TestHelpers.Instance.CharacterDao,
_friendRequestHolder, _connectedAccountHttpClient.Object);
_friendHttpClient.Setup(s => s.AddFriend(It.IsAny <FriendShipRequest>()))
.Returns(friend.AddFriend(new FriendShipRequest
{
CharacterId = _session.Character.CharacterId, FinsPacket = finsPacket
}));
_finsPacketHandler.Execute(finsPacket, _session);
Assert.IsTrue(_characterRelationDao.LoadAll().Count() == 2);
}
public async void GetRequestedFriends_Test()
{
// Arrange
var user = CreatePerson();
var friend1 = CreatePerson();
var friend2 = CreatePerson();
var listOfFriends = new List <Person>()
{
friend1,
friend2
};
_personRepository
.Setup(x => x.Single(It.IsAny <Expression <Func <Person, bool> > >()))
.ReturnsAsync(user);
_friendRepository
.Setup(x =>
x.GetFriendRequests(
It.IsAny <Person>(),
It.IsAny <FriendsWith>()))
.ReturnsAsync(listOfFriends);
var personController = new PersonController(_personRepository.Object, _mapper, _emailHelper.Object, _tokenClass.Object);
var friendController = new FriendController(_personRepository.Object, _friendRepository.Object, _mapper);
// Act
var result = await friendController.GetFriendRequests(user.Name);
var okResult = result as OkObjectResult;
var returnedFriendRequestsJSON = okResult.Value as string;
var returnedFriendRequests = JsonSerializer.Deserialize <List <Person> >(returnedFriendRequestsJSON);
// Assert
Assert.True(okResult != null);
Assert.Equal(200, okResult.StatusCode);
Assert.True(returnedFriendRequests.Count == listOfFriends.Count);
}
private void Throw()
{
Rigidbody heldRigid = holding.GetComponent <Rigidbody>();
heldRigid.isKinematic = false;
holding.transform.parent = transform.parent;
if (holding.tag == "Player")
{
FriendController otherPlayer = holding.GetComponent <FriendController>();
otherPlayer.pickedUp = false;
otherPlayer.knockdownTimer = knockdownTime;
}
if (holding.GetComponent <Bomb>() != null)
{
holding.GetComponent <Bomb>().Thrown();
}
holding = null;
Vector3 throwVector = transform.forward.normalized;
throwVector = Quaternion.AngleAxis(throwAngle, transform.right) * throwVector * throwForce;
heldRigid.AddForce(throwVector);
}
public async void RequestFriendRoute_Test()
{
// Arrange
var user = CreatePerson();
var friend = CreatePerson();
var requestedFriends = new List <Person>();
_personRepository
.Setup(x => x.Single(p => p.Name == user.Name))
.ReturnsAsync(user);
_personRepository
.Setup(x => x.Single(p => p.Name == friend.Name))
.ReturnsAsync(friend);
_personRepository
.Setup(x =>
x.Relate <Person, FriendsWith>(
It.IsAny <Expression <Func <Person, bool> > >(),
It.IsAny <Expression <Func <Person, bool> > >(),
It.IsAny <FriendsWith>()))
.ReturnsAsync(true)
.Callback <Expression <Func <Person, bool> >, Expression <Func <Person, bool> >, FriendsWith>(
(exp1, exp2, friendsWith) => { requestedFriends.Add(friend); }
);
var personController = new PersonController(_personRepository.Object, _mapper, _emailHelper.Object, _tokenClass.Object);
var friendController = new FriendController(_personRepository.Object, _friendRepository.Object, _mapper);
// Act
var result = await friendController.RequestFriend(user.Name, friend.Name);
var okResult = result as OkObjectResult;
// Assert
Assert.True(okResult != null);
Assert.Equal(200, okResult.StatusCode);
}
public void KnockDown(float impulse)
{
Debug.Log("Knocked down.");
rigid.constraints = RigidbodyConstraints.None;
knockedDown = true;
knockdownTimer = knockdownTime * impulse;
if (knockdownTimer > 3f)
{
knockdownTimer = 3f;
}
if (holding != null)
{
holding.GetComponent <Rigidbody>().isKinematic = false;
holding.transform.parent = transform.parent;
if (holding.tag == "Player")
{
FriendController otherPlayer = holding.GetComponent <FriendController>();
otherPlayer.pickedUp = false;
otherPlayer.Standup();
}
holding = null;
}
}
public void SpawnPlayer(Player player)
{
player.isPlaying = true;
PlayerJoinedArgs args = new PlayerJoinedArgs();
args.player = player;
args.playerId = player.id;
OnPlayerJoined(args);
GameObject newPlayer = Instantiate(playerObj);
if (players.Any(p => p == null))
{
int index = players.FindIndex(p => p == null);
args.playerNum = index;
Debug.Log("Player spawned as player: " + index);
players[index] = player;
newPlayer.GetComponent <Renderer>().material.SetColor("_BaseColor", playerColors[index]);
}
else
{
Debug.Log("Spawned as player: " + players.Count);
newPlayer.GetComponent <Renderer>().material.SetColor("_BaseColor", playerColors[players.Count]);
args.playerNum = players.Count;
players.Add(player);
}
FriendController controller = newPlayer.GetComponent <FriendController>();
controller.playerId = player.id;
controller.playerNum = args.playerNum;
controller.Respawn();
playerObjects.Add(player, newPlayer);
targetGroup.AddMember(newPlayer.transform, 1f, 0f);
}
public void Init() // initialize screen components
{
BackgroundColor = Constants.backgroundColor;
boxViewFriends.Color = Constants.logoColorYellow;
friendController = new FriendController();
}
public FriendMenu(FriendController controllerFriend, ConsoleColor fontColor)
{
MenuTypeTitle = "friend";
mainController = controllerFriend;
this.fontColor = fontColor;
}
public void Init() //initialize screen components
{
BackgroundColor = Constants.backgroundColor;
userController = new UserController();
friendController = new FriendController();
}
public void GivenInitializeMockingData()
{
var mock = ScenarioContext.Current.Get <MockRepository>();
var classRoomRepo = mock.Create <IClassRoomRepository>();
var likeLessonRepo = mock.Create <ILikeLessonRepository>();
var userprofileRepo = mock.Create <IUserProfileRepository>();
var classCalendarRepo = mock.Create <IClassCalendarRepository>();
var lessonCatalogRepo = mock.Create <ILessonCatalogRepository>();
var commentRepo = mock.Create <ICommentRepository>();
var friendRequestRepo = mock.Create <IFriendRequestRepository>();
var userActivityRepo = mock.Create <IUserActivityRepository>();
var likeCommentRepo = mock.Create <ILikeCommentRepository>();
var likeDiscussionRepo = mock.Create <ILikeDiscussionRepository>();
var studentKeyRepo = mock.Create <IStudentKeyRepository>();
var notificationRepo = mock.Create <INotificationRepository>();
var dateTime = mock.Create <IDateTime>();
ScenarioContext.Current.Set(classRoomRepo);
ScenarioContext.Current.Set(likeLessonRepo);
ScenarioContext.Current.Set(userprofileRepo);
ScenarioContext.Current.Set(classCalendarRepo);
ScenarioContext.Current.Set(lessonCatalogRepo);
ScenarioContext.Current.Set(commentRepo);
ScenarioContext.Current.Set(friendRequestRepo);
ScenarioContext.Current.Set(userActivityRepo);
ScenarioContext.Current.Set(likeCommentRepo);
ScenarioContext.Current.Set(likeDiscussionRepo);
ScenarioContext.Current.Set(studentKeyRepo);
ScenarioContext.Current.Set(notificationRepo);
ScenarioContext.Current.Set(dateTime);
var notificationCtrl = new NotificationController(userprofileRepo.Object,
notificationRepo.Object,
likeLessonRepo.Object,
likeCommentRepo.Object,
likeDiscussionRepo.Object,
commentRepo.Object,
classCalendarRepo.Object,
friendRequestRepo.Object,
dateTime.Object);
var myCourseCtrl = new LessonController(classCalendarRepo.Object,
userprofileRepo.Object,
classRoomRepo.Object,
likeLessonRepo.Object,
lessonCatalogRepo.Object,
commentRepo.Object,
friendRequestRepo.Object,
userActivityRepo.Object,
notificationCtrl,
dateTime.Object);
var commentCtrl = new CommentController(classCalendarRepo.Object,
userprofileRepo.Object,
commentRepo.Object,
userActivityRepo.Object,
likeCommentRepo.Object,
notificationCtrl,
dateTime.Object);
var discussionCtrl = new DiscussionController(classCalendarRepo.Object,
userprofileRepo.Object,
commentRepo.Object,
userActivityRepo.Object,
likeDiscussionRepo.Object,
notificationCtrl,
dateTime.Object);
var mycourseCtrl = new MyCourseController(classCalendarRepo.Object,
userprofileRepo.Object,
userActivityRepo.Object,
classRoomRepo.Object,
studentKeyRepo.Object,
lessonCatalogRepo.Object,
likeLessonRepo.Object,
likeCommentRepo.Object,
likeDiscussionRepo.Object,
dateTime.Object);
var friendCtrl = new FriendController(classCalendarRepo.Object,
userprofileRepo.Object,
friendRequestRepo.Object,
userActivityRepo.Object,
dateTime.Object);
ScenarioContext.Current.Set(notificationCtrl);
ScenarioContext.Current.Set(myCourseCtrl);
ScenarioContext.Current.Set(commentCtrl);
ScenarioContext.Current.Set(discussionCtrl);
ScenarioContext.Current.Set(mycourseCtrl);
ScenarioContext.Current.Set(friendCtrl);
}
private Boolean canPass()
{
FriendController c = new FriendController();
return(passAction(c.AddFriend) || passAction(c.SaveFriend));
}
/*--------------------------------------------------------------------------------------*/
/* */
/* LoadAndRunConversationWith: Navigates through conversations and handles the */
/* conversation's states */
/* param: FriendController friend - Lets us know which friend and what */
/* suspcion level they have */
/* */
/*--------------------------------------------------------------------------------------*/
public void LoadAndRunConversationWith(FriendController friend)
{
// Sets our friend reference incase we need it outside this function
m_FriendReference = friend;
// All conversation stuff for GianCarlo goes in here
if (friend.friendName.Equals("GC"))
{
// We check GC's suspciion level and load the appropriate file and split each line at the neter key "\n"
if (friend.conversationCheck[3] && friend.suspicionLevel == 3)
{
textFile = Resources.Load("GC_SusLvl4") as TextAsset;
textLines = (textFile.text.Split('\n'));
endAtLine = textLines.Length - 1;
/*
* Logic for suspicion level 4 goes here
*/
}
else if (friend.conversationCheck[2] && friend.suspicionLevel == 2)
{
textFile = Resources.Load("GC_SusLvl3") as TextAsset;
textLines = (textFile.text.Split('\n'));
endAtLine = textLines.Length - 1;
/*
* Logic for suspicion level 3 goes here
*/
}
else if (friend.conversationCheck[1] && friend.suspicionLevel == 1)
{
textFile = Resources.Load("GC_SusLvl2") as TextAsset;
textLines = (textFile.text.Split('\n'));
endAtLine = textLines.Length - 1;
/*
* Logic for suspicion level 2 goes here
*/
}
else if (friend.conversationCheck[0])
{
/*---------------Logic for Suspicion level 1 of GC------------------*/
//If we've gone through this conversation with raising suspicion we skip all the if statements
if (!conversationPasses [3])
{
// Loads the file
textFile = Resources.Load("GC_SusLvl1") as TextAsset;
// At line 7 which is a "..." we start the conversation steering slider
if (currentLine == 7)
{
// We've passed conversation steering part of the conversation
conversationPasses [0] = true;
// We are now steering a conversation. Make the slider appear and make it move
conversation.transform.localScale = m_Appear;
steerConversation = true;
conversation.GetComponent <Conversation> ().startSlider = true;
// Start the timer
StartCoroutine(SteerConversationTimer(3f));
}
// Disables input for 1.5 seconds to prevent player from clicking through dialogue
if (currentLine == 8)
{
StartCoroutine(DiableInputTimer(5f));
}
// This is here to make the dialouge flow smoothly after failure and success states
if (currentLine == 9)
{
currentLine = 12;
}
if (currentLine == 11)
{
currentLine = 12;
}
// At line 21 which is a "..." we start the conversation steering slider
if (currentLine == 21)
{
// We've passed conversation steering part of the conversation
conversationPasses [1] = true;
// We are now steering a conversation. Make the slider appear and make it move
conversation.transform.localScale = m_Appear;
steerConversation = true;
conversation.GetComponent <Conversation> ().startSlider = true;
// Start the timer
StartCoroutine(SteerConversationTimer(3f));
}
// Disables input for 1.5 seconds to prevent player from clicking through dialogue
if (currentLine == 22)
{
StartCoroutine(DiableInputTimer(5f));
}
// This is here to make the dialouge flow smoothly after failure and success states
if (currentLine == 23)
{
currentLine = 26;
}
if (currentLine == 25)
{
currentLine = 26;
}
// At line 29 which is a "..." we start the conversation steering slider
if (currentLine == 29)
{
// We've passed conversation steering part of the conversation
conversationPasses [2] = true;
// We are now steering a conversation. Make the slider appear and make it move
conversation.transform.localScale = m_Appear;
steerConversation = true;
conversation.GetComponent <Conversation> ().startSlider = true;
// Start the timer
StartCoroutine(SteerConversationTimer(3f));
}
// Disables input for 1.5 seconds to prevent player from clicking through dialogue
if (currentLine == 30)
{
StartCoroutine(DiableInputTimer(1.5f));
}
// This is here to make the dialouge flow smoothly after failure and success states
if (currentLine == 31)
{
currentLine = 34;
}
if (currentLine == 33)
{
currentLine = 34;
}
// We have passed through this conversation text file. The last line will now appear
if (currentLine == 41)
{
conversationPasses [3] = true;
currentLine = 41;
}
// Hides the pannel
if (currentLine == 42)
{
panel.SetActive(false);
}
}
else
{
// Makes panel appear with the "hold on I'm getting a text line"
panel.SetActive(true);
}
//Sets the appropriate length for each text file
textLines = (textFile.text.Split('\n'));
endAtLine = textLines.Length - 1;
}
}
// Emptys the text panel after each block of text
theText.text = "";
// Displays text on the panel
currentTextLine = textLines [currentLine];
// Seprates text line word by word
StartCoroutine(TypeText(currentTextLine));
}
private void Start()
{
friendController = transform.parent.gameObject.GetComponent <FriendController>();
playerController = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerController>();
}
