/// <summary>
/// Returns a character with the default configuration. This can be called on client and server.
/// </summary>
/// <returns></returns>
private CharacterResponse GetDefaultCharacter()
{
CharacterResponse character = new CharacterResponse();
character.name = "John Doe";
return(character);
}
public void SpawnPlayerAfterRoundStart(NetworkConnection conn)
{
Debug.Log("Spawn player from address " + conn.address);
CharacterResponse character = SpawnPlayerWithoutLoginServer(conn);
Debug.Log("Spawning player after round start " + "conn: " + conn.address + " character: " + character.name);
//Something has gone horribly wrong
if (character == null)
{
throw new Exception("Could not read character data");
}
// Spawn player based on their character choices
Transform startPos = GetStartPosition();
GameObject player = startPos != null
? Instantiate(playerPrefab, startPos.position, startPos.rotation)
: Instantiate(playerPrefab);
player.name = character.name;
if (NetworkClient.connection.identity != null)
{
NetworkServer.DestroyPlayerForConnection(conn);
}
//Destroy dummy player
//NetworkServer.DestroyPlayerForConnection(conn);
//Spawn actual player
NetworkServer.AddPlayerForConnection(conn, player);
}
public async Task <ServiceResponse <CharacterResponse> > GetAllCharacter()
{
ServiceResponse <CharacterResponse> serviceResponse = new ServiceResponse <CharacterResponse>();
DataResponse <CharacterResponse> dataResponse = new DataResponse <CharacterResponse>();
try
{
this.QueryData();
List <CharacterResponse> lCharacters = new List <CharacterResponse>();
foreach (var itemCharacter in characters)
{
CharacterResponse characterResponse = new CharacterResponse();
characterResponse.Id = itemCharacter.Id;
characterResponse.Name = itemCharacter.Name;
characterResponse.Description = itemCharacter.Description;
characterResponse.ResourceURI = itemCharacter.ResourceUri;
characterResponse.Comics = AddComics(comics.Where(item => item.Equals(itemCharacter.Id)));
characterResponse.Series = AddSeries(series.Where(item => item.Equals(itemCharacter.Id)));
characterResponse.Stories = AddStories(stories.Where(item => item.Equals(itemCharacter.Id)));
characterResponse.Events = AddEvents(events.Where(item => item.Equals(itemCharacter.Id)));
lCharacters.Add(characterResponse);
}
dataResponse.Results = lCharacters;
serviceResponse.data = dataResponse;
return(serviceResponse);
}
catch (Exception)
{
return(serviceResponse);
}
}
public override void OnServerAddPlayer(NetworkConnection conn, AddPlayerMessage extraMessage)
{
if (!IsPlayerPrefabValid(conn))
{
return;
}
if (extraMessage?.value == null)
{
base.OnServerAddPlayer(conn, null);
return;
}
/*
* Deserialize character data from byte[]
* Format controlled in SpawnPlayerWithLoginServer()
* Current expected format:
* {
* "name" : "SomePlayerName"
* }
*/
string rawJson = System.Text.Encoding.UTF8.GetString(extraMessage.value);
string name = CharacterResponse.CreateFromJSON(rawJson).name;
//Spawn player based on their character choices
Transform startPos = GetStartPosition();
GameObject player = startPos != null
? Instantiate(playerPrefab, startPos.position, startPos.rotation)
: Instantiate(playerPrefab);
player.name = name;
NetworkServer.AddPlayerForConnection(conn, player);
}
private CharacterResponse SpawnPlayerWithoutLoginServer(NetworkConnection conn)
{
CharacterResponse characterResponse = GetDefaultCharacter();
conn.Send(new CharacterSelectMessage {
character = characterResponse
});
return(characterResponse);
}
/**
* If the client is told that the login server doesn't exist, we build them a John Doe.
*/
private void SpawnPlayerWithoutLoginServer(NetworkConnection conn)
{
CharacterResponse characterResponse = new CharacterResponse();
characterResponse.name = "John Doe";
conn.Send(new CharacterSelectMessage {
character = characterResponse
});
}
private void SpawnPlayerWithLoginServer(NetworkConnection conn, CharacterResponse characterResponse)
{
ClientScene.Ready(conn);
string json = JsonUtility.ToJson(characterResponse);
//Convert to byte[] and send
byte[] data = System.Text.Encoding.UTF8.GetBytes(json);
ClientScene.AddPlayer(conn, data);
}
public static CharacterResponse[] ToResponse(Character[] characters)
{
List <CharacterResponse> responses = new List <CharacterResponse>();
foreach (Character character in characters)
{
responses.Add(CharacterResponse.FromCharacter(character));
}
return(responses.ToArray());
}
public void HandleCharacterSelectButton()
{
CharacterResponse characterResponse = characterScreen.GetSelectedCharacterData();
if (characterResponse == null)
{
characterScreen.DisplayErrorMessage("Could not find character data.");
return;
}
loginManager.SpawnPlayer(characterResponse);
}
public async Task GetCharacterDetailsAsync_ShouldLoadCharacterFromService_ThenMapItIntoCharacterResponse_WhenNoGroup()
{
const int characterId = 2;
var character = new Character();
var characterResponse = new CharacterResponse();
_characterService.LoadCharacterDetailsAsync(_executionContext, characterId)
.Returns(character);
_mapper.Map <CharacterResponse>(character)
.Returns(characterResponse);
var result = await _controller.GetCharacterDetailsAsync(_executionContext, characterId);
result.Value.Should().BeSameAs(characterResponse);
}
public IAsyncResult BeginCreate(CreateRequest request, string acctname, string name, AsyncCallback callback, object asyncState)
{
CharacterResponse response = null;
Account account = Account.Login(acctname, request.Login.Password);
if (account != null)
{
response = Character.Create(account, name, request.Class, request.Race, request.Faction);
}
else
{
response = new CharacterResponse("Error: Bad username or password.", null);
}
return(new CompletedAsyncResult <CharacterResponse>(response));
}
bool ValidateIfDuplicateOrExcluded(Comment comment, string compareComment, CharacterResponse response)
{
//Dont post response if phrase matched excluded phrases
if (Constants.EXCLUDE_PHRASES.Any(x => x.ToLower() == compareComment))
{
return(false);
}
//Dont reply if bot has already replied
if (comment.Comments.Any(x => x.AuthorName == m_botUsername))
{
return(false);
}
else
{
return(true);
}
}
public IAsyncResult BeginDelete(CharacterBaseRequest request, string acctname, string name, AsyncCallback callback, object asyncState)
{
CharacterResponse response = null;
Account account = Account.Login(acctname, request.Login.Password);
if (account != null)
{
response = Character.Load(acctname, name);
if (response.Success)
{
string message = response.Character.Delete();
response = new CharacterResponse(message, response.Character);
}
}
else
{
response = new CharacterResponse("Error: Bad username or password.", null);
}
return(new CompletedAsyncResult <CharacterResponse>(response));
}
void HandleCharacterRequest()
{
CharacterResponse response = new CharacterResponse();
DataRow[] tmp = accountData.GetChildRows("AccountData_CharacterData");
if (tmp.Length == 0)
{
Console.WriteLine("0 characters");
}
else
{
for (int i = 0; i < tmp.Length; i++)
{
response.Names[i] = (tmp[i] as PlayerData.CharacterDataRow).Name;
response.Images[i] = (tmp[i] as PlayerData.CharacterDataRow).Image;
}
}
response.CharacterCount = (Byte)tmp.Length;
client.BeginSend(response);
}
/// <summary>
/// Posts a formatted reply with the voice line linking to the voice line url to a comment
/// </summary>
/// <param name="originalComment">The original comment</param>
/// <param name="responseLine">The response line</param>
void PostReply(Comment originalComment, CharacterResponse response)
{
//Check AuthorName & Body to see if it's the same
if (m_repliedToComments.Any(c => c.Body == originalComment.Body && c.AuthorName == originalComment.AuthorName))
{
return;
}
Debug.Log($"Replying to '{originalComment.AuthorName}'s comment with response '{response.Character}' - '{response.Response}'");
string reply = $"[{response.Character}: {response.Response}]({response.Url})" +
Environment.NewLine +
"*****" +
Environment.NewLine +
"^^Got ^^a ^^question? ^^Ask ^^/u/JoshLmao ^^- ^^[Github](https://github.com/JoshLmao/WitcherResponsesBot) ^^- ^^[Suggestions/Issues](https://github.com/JoshLmao/WitcherResponsesBot/issues)";
m_redditService.ReplyToComment(originalComment, reply);
m_repliedToComments.Add(originalComment);
response.UseCount++;
}
public IEnumerator GetData()
{
UnityWebRequest www = UnityWebRequest.Get("https://api.airtable.com/v0/appQ3dmrqe9MBHoos/Characters?maxRecords=" + maxRecords + "&view=" + view);
www.SetRequestHeader("Authorization", "Bearer " + airtableConfig.token);
yield return(www.Send());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log("AirtableConfig is not valid");
airtableConfig.isValid = false;
}
else
{
Debug.Log("AirtableConfig is valid");
Debug.Log(www.downloadHandler.text);
response = JsonUtility.FromJson <CharacterResponse> (www.downloadHandler.text);
if (OnUpdate != null)
{
OnUpdate();
}
}
}
public IAsyncResult BeginUpdate(UpdateRequest request, string acctname, string name, AsyncCallback callback, object asyncState)
{
CharacterResponse response = null;
Account account = Account.Login(acctname, request.Login.Password);
if (account != null)
{
response = Character.Load(acctname, name);
if (response.Success && !response.Character.Deleted)
{
string message = response.Character.UpdateCharacter(account, request.Faction, request.Race, request.Class);
if (message != string.Empty)
{
response = new CharacterResponse(message, response.Character);
}
}
}
else
{
response = new CharacterResponse("Error: Bad username or password.", null);
}
return(new CompletedAsyncResult <CharacterResponse>(response));
}
public async Task <IActionResult> Get(string hero, string villain)
{
var characters = await _charactersProvider.GetCharacters();
foreach (var character in characters.Items)
{
if (character.Name == hero)
{
_character1 = character;
}
if (character.Name == villain)
{
_character2 = character;
}
}
if (_character1.Score > _character2.Score)
{
return(Ok(_character1));
}
return(Ok(_character2));
}
private static void PrintResult(CharacterResponse response)
{
var result = $"Name: {response.Name}, Gender: {response.Gender}, Height: {response.Height}";
Console.WriteLine(result);
}
public void SpawnPlayer(CharacterResponse characterResponse)
{
spawnPlayerAction(characterResponse);
HideLoginWindow();
}
/**
* Once the player has selected a character, the client tells the server of the chosen character.
*/
private void SpawnPlayerWithLoginServer(NetworkConnection conn, CharacterResponse characterResponse)
{
conn.Send(new CharacterSelectMessage {
character = characterResponse
});
}
public bool HandleRequest(Client client, HttpListenerContext context, params string[] args)
{
if (!UserManager.Connected(client))
{
context.Send("not connected");
return(true);
}
User user = UserManager.GetUser(UserManager.GetUserID(client));
if (user == null)
{
context.Send("user not found");
return(true);
}
if (context.Request.HttpMethod == "POST")
{
if (args.Length == 0)
{
return(true);
}
if (args[0] == "create")
{
string body = new StreamReader(context.Request.InputStream).ReadToEnd();
JObject json = JObject.Parse(body);
string replaced = CharacterManager.DefaultCharacterJSON.Replace("__NAME__", json["charactername"].ToString());
JObject data = JObject.Parse(replaced);
CharacterManager.CreateCharacter(user, JsonConvert.SerializeObject(data));
return(true);
}
if (args.Length == 2 && args[1] == "update")
{
string body = new StreamReader(context.Request.InputStream).ReadToEnd();
JObject json = JObject.Parse(body);
// TODO add some validation here to make sure we don't receive junk
int characterId = Convert.ToInt32(args[0]);
CharacterManager.UpdateCharacter(characterId, JsonConvert.SerializeObject(json));
}
if (args.Length == 2)
{
int characterId = Convert.ToInt32(args[0]);
Character character = CharacterManager.GetCharacter(characterId);
if (character == null)
{
return(true);
}
if (character.UserId != user.Id)
{
return(true);
}
if (args[1] == "delete")
{
CharacterManager.DeleteCharacter(characterId);
}
return(true);
}
}
int id = Convert.ToInt32(args[0]);
Character carac = CharacterManager.GetCharacter(id);
context.Send(SerializationHelper.SerializeToJSON(CharacterResponse.FromCharacter(carac)));
return(true);
}
