private VerifierResult SlowVerify(Player source, ISkill skill, List <Card> cards, List <Player> players)
{
VerifierResult initialResult = FastVerify(source, skill, cards, players);
if (Properties.Settings.Default.IsUsing386)
{
return(initialResult);
}
if (skill != null)
{
if (initialResult == VerifierResult.Success)
{
return(VerifierResult.Success);
}
bool NothingWorks = true;
List <Card> tryList = new List <Card>();
if (cards != null)
{
tryList.AddRange(cards);
}
var cardsToTry = new List <Card>(Game.CurrentGame.Decks[source, DeckType.Hand].Concat(Game.CurrentGame.Decks[source, DeckType.Equipment]));
foreach (var dk in skill.Helper.OtherDecksUsed)
{
cardsToTry.AddRange(Game.CurrentGame.Decks[source, dk]);
}
foreach (Card c in cardsToTry)
{
tryList.Add(c);
if (FastVerify(source, skill, tryList, players) != VerifierResult.Fail)
{
NothingWorks = false;
break;
}
tryList.Remove(c);
}
List <Player> tryList2 = new List <Player>();
if (players != null)
{
tryList2.AddRange(players);
}
foreach (Player p in Game.CurrentGame.Players)
{
tryList2.Add(p);
if (FastVerify(source, skill, cards, tryList2) != VerifierResult.Fail)
{
NothingWorks = false;
break;
}
tryList2.Remove(p);
}
if (NothingWorks)
{
return(VerifierResult.Fail);
}
}
return(initialResult);
}
public static int CalculateBadPoints(VerifierResult res)
{
return(
res.MalformedWadFiles.Length +
res.MisnamedModDirs.Length * 2 +
res.NotExistingFiles.Length * 4
);
}
public override VerifierResult FastVerify(Player source, ISkill skill, List <Card> cards, List <Player> players)
{
if (players != null && players.Any(p => p.IsDead))
{
return(VerifierResult.Fail);
}
if ((cards == null || cards.Count == 0) && skill == null)
{
return(VerifierResult.Fail);
}
if (skill is CheatSkill)
{
if (!Game.CurrentGame.Settings.CheatEnabled)
{
return(VerifierResult.Fail);
}
return(VerifierResult.Success);
}
else if (skill is ActiveSkill)
{
GameEventArgs arg = new GameEventArgs();
arg.Source = Game.CurrentGame.CurrentPlayer;
arg.Targets = players;
arg.Cards = cards;
return(((ActiveSkill)skill).Validate(arg));
}
else if (skill is CardTransformSkill)
{
CardTransformSkill s = (CardTransformSkill)skill;
CompositeCard result;
VerifierResult ret = s.TryTransform(cards, players, out result);
if (ret == VerifierResult.Success)
{
return(result.Type.Verify(Game.CurrentGame.CurrentPlayer, skill, cards, players));
}
if (ret == VerifierResult.Partial && players != null && players.Count != 0)
{
return(VerifierResult.Fail);
}
return(ret);
}
else if (skill != null)
{
return(VerifierResult.Fail);
}
if (cards[0].Place.DeckType != DeckType.Hand)
{
return(VerifierResult.Fail);
}
return(cards[0].Type.Verify(Game.CurrentGame.CurrentPlayer, skill, cards, players));
}
private AccessTokenResult RetrieveAccessToken(VerifierResult verifierResult)
{
if (verifierResult == null)
{
throw new ArgumentNullException("verifierResult");
}
if (string.IsNullOrEmpty(verifierResult.OAuthToken))
{
throw new ArgumentException("verifierResult.OAuthToken");
}
if (string.IsNullOrEmpty(verifierResult.OAuthToken))
{
throw new ArgumentException("verifierResult.OAuthVerifier");
}
IRestResponse response;
try
{
var request = new RestRequest("oauth/access_token", Method.POST);
var restClient = RestClientFactory.CreateRestClient(BaseUrl);
restClient.Authenticator = OAuth1Authenticator.ForAccessToken(_consumerKey, _consumerSecret,
verifierResult.OAuthToken,
null, verifierResult.OAuthVerifier);
response = restClient.Execute(request);
}
catch (Exception exception)
{
throw new AuthenticationException("Failed to convert Request Token to an Access Token, from Twitter.",
exception);
}
if (response == null || response.StatusCode != HttpStatusCode.OK)
{
throw new AuthenticationException(
string.Format(
"Failed to obtain an Access Token from Twitter OR the the response was not an HTTP Status 200 OK. Response Status: {0}. Response Description: {1}",
response == null ? "-- null response --" : response.StatusCode.ToString(),
response == null ? string.Empty : response.StatusDescription));
}
var querystringParameters = HttpUtility.ParseQueryString(response.Content);
return(new AccessTokenResult
{
AccessToken = querystringParameters[OAuthTokenKey],
AccessTokenSecret = querystringParameters[OAuthTokenSecretKey]
});
}
public void ReturnResultFromVerifier(VerifierResult toReturn)
{
var verifier = new MockVerifier()
{
Return = toReturn
};
var provider = new CustomFakeLevelsProvider()
{
Level = null
};
var command = new VerifyCommand(provider, verifier);
var result = command.Execute("", "");
Assert.Equal(toReturn, result);
}
protected void RunVerifierTestCase(string file)
{
string boo = GetBooFile(file);
string asm = GetTempFileName();
WriteAssemblyScript was = CompileBooFile <WriteAssemblyScript> (boo);
was.DefineAssembly(file);
was.Run();
AssemblyFactory.SaveAssembly(was.ASM, asm);
IVerifier verifier = new ManagedVerifier(AssemblyFactory.GetAssembly(asm));
VerifierResult result = verifier.Run();
RunAndAssertOutput(boo, delegate
{
foreach (ResultItem item in result.GetItems())
{
Console.WriteLine(item);
}
});
}
private AccessTokenResult RetrieveAccessToken(VerifierResult verifierResult)
{
if (verifierResult == null)
{
throw new ArgumentNullException("verifierResult");
}
if (string.IsNullOrEmpty(verifierResult.OAuthToken))
{
throw new ArgumentException("verifierResult.OAuthToken");
}
if (string.IsNullOrEmpty(verifierResult.OAuthVerifier))
{
throw new ArgumentException("verifierResult.OAuthVerifier");
}
IRestResponse response;
try
{
var restRequest = new RestRequest("oauth/access_token", Method.POST);
var restClient = RestClientFactory.CreateRestClient(BaseUrl);
TraceSource.TraceVerbose("Retrieving Access Token endpoint: {0}",
restClient.BuildUri(restRequest).AbsoluteUri);
restClient.Authenticator = OAuth1Authenticator.ForAccessToken(PublicApiKey, SecretApiKey,
verifierResult.OAuthToken,
null,
verifierResult.OAuthVerifier);
response = restClient.Execute(restRequest);
}
catch (Exception exception)
{
var errorMessage =
string.Format("Failed to retrieve an oauth access token from Twitter. Error Messages: {0}",
exception.RecursiveErrorMessages());
TraceSource.TraceError(errorMessage);
throw new AuthenticationException(errorMessage, exception);
}
if (response == null ||
response.StatusCode != HttpStatusCode.OK)
{
var errorMessage = string.Format(
"Failed to obtain an Access Token from Twitter OR the the response was not an HTTP Status 200 OK. Response Status: {0}. Response Description: {1}. Error Content: {2}. Error Message: {3}.",
response == null ? "-- null response --" : response.StatusCode.ToString(),
response == null ? string.Empty : response.StatusDescription,
response == null ? string.Empty : response.Content,
response == null
? string.Empty
: response.ErrorException == null
? "--no error exception--"
: response.ErrorException.RecursiveErrorMessages());
TraceSource.TraceError(errorMessage);
throw new AuthenticationException(errorMessage);
}
var querystringParameters = HttpUtility.ParseQueryString(response.Content);
TraceSource.TraceVerbose("Retrieved OAuth Token - Public Key: {0}. Secret Key: {1} ",
string.IsNullOrEmpty(querystringParameters[OAuthTokenKey])
? "no public key retrieved from the querystring. What Ze F**k?"
: querystringParameters[OAuthTokenKey],
string.IsNullOrEmpty(querystringParameters[OAuthTokenSecretKey])
? "no secret key retrieved from the querystring. What Ze F**k?"
: querystringParameters[OAuthTokenSecretKey]);
return(new AccessTokenResult
{
AccessToken = querystringParameters[OAuthTokenKey],
AccessTokenSecret = querystringParameters[OAuthTokenSecretKey]
});
}
public override void Run(GameEvent gameEvent, GameEventArgs eventArgs)
{
Player currentPlayer = Game.CurrentGame.CurrentPlayer;
Trace.TraceInformation("Player {0} action.", currentPlayer.Id);
while (!currentPlayer.IsDead)
{
bool newturn = false;
foreach (var pl in Game.CurrentGame.Players)
{
if (GetReadyToGo(pl) && pl == currentPlayer)
{
newturn = true;
}
}
if (newturn)
{
return;
}
Trace.Assert(Game.CurrentGame.UiProxies.ContainsKey(currentPlayer));
IPlayerProxy proxy = Game.CurrentGame.UiProxies[currentPlayer];
ISkill skill;
List <Card> cards;
List <Player> players;
PlayerActionStageVerifier v = new PlayerActionStageVerifier();
Game.CurrentGame.Emit(GameEvent.PlayerIsAboutToUseCard, new PlayerIsAboutToUseOrPlayCardEventArgs()
{
Source = currentPlayer, Verifier = v
});
if (!proxy.AskForCardUsage(new Prompt(Prompt.PlayingPhasePrompt), v, out skill, out cards, out players))
{
break;
}
if (skill != null)
{
if (skill is CheatSkill)
{
if (!Game.CurrentGame.Settings.CheatEnabled)
{
break;
}
CheatSkill cs = skill as CheatSkill;
if (cs.CheatType == CheatType.Card)
{
if (Game.CurrentGame.IsClient)
{
Game.CurrentGame.SyncUnknownLocationCardAll(null);
}
else
{
foreach (var searchCard in Game.CurrentGame.CardSet)
{
if (searchCard.Id == cs.CardId)
{
Game.CurrentGame.SyncUnknownLocationCardAll(searchCard);
break;
}
}
}
foreach (var searchCard in Game.CurrentGame.CardSet)
{
if (searchCard.Id == cs.CardId)
{
CardsMovement move = new CardsMovement();
move.Cards = new List <Card>()
{
searchCard
};
move.To = new DeckPlace(Game.CurrentGame.CurrentPlayer, DeckType.Hand);
move.Helper = new MovementHelper();
Game.CurrentGame.MoveCards(move);
break;
}
}
}
else if (cs.CheatType == CheatType.Skill)
{
foreach (var hero in Game.CurrentGame.OriginalCardSet)
{
bool found = false;
if (hero.Type is HeroCardHandler)
{
foreach (var sk in (hero.Type as HeroCardHandler).Hero.Skills)
{
if (sk.GetType().Name == cs.SkillName)
{
Game.CurrentGame.PlayerAcquireAdditionalSkill(currentPlayer, sk.Clone() as ISkill, currentPlayer.Hero);
found = true;
break;
}
}
}
if (found)
{
break;
}
}
}
continue;
}
else if (skill is ActiveSkill)
{
GameEventArgs arg = new GameEventArgs();
arg.Source = Game.CurrentGame.CurrentPlayer;
arg.Targets = players;
arg.Cards = cards;
((ActiveSkill)skill).NotifyAndCommit(arg);
Game.CurrentGame.NotificationProxy.NotifyActionComplete();
Game.CurrentGame.LastAction = skill;
continue;
}
CompositeCard c;
CardTransformSkill s = (CardTransformSkill)skill;
VerifierResult r = s.TryTransform(cards, players, out c);
Trace.TraceInformation("Player used {0}", c.Type);
}
else
{
Trace.Assert(cards[0] != null && cards.Count == 1);
Trace.TraceInformation("Player used {0}", cards[0].Type);
}
try
{
Game.CurrentGame.Emit(GameEvent.CommitActionToTargets, new Triggers.GameEventArgs()
{
Skill = skill, Source = Game.CurrentGame.CurrentPlayer, Targets = players, Cards = cards
});
}
catch (TriggerResultException)
{
}
Game.CurrentGame.NotificationProxy.NotifyActionComplete();
Game.CurrentGame.LastAction = skill;
}
}
public void ReturnDeserializedResultFromCreatedProcess(MockJarFileProcessFactory factory, VerifierResult expected)
{
var verifier = new JarFileVerifier(factory);
var result = verifier.Verify(new Level(), "");
Assert.Equal(expected, result, new VerifierResultEqualityComparer());
}
public override VerifierResult FastVerify(Player source, ISkill skill, List <Card> cards, List <Player> players)
{
if (players != null && players.Count != 0)
{
return(VerifierResult.Fail);
}
if (skill != null)
{
CompositeCard card;
if (!(skill is CardTransformSkill))
{
return(VerifierResult.Fail);
}
CardTransformSkill s = (CardTransformSkill)skill;
VerifierResult r = s.TryTransform(cards, players, out card, !isUseCard);
if (r != VerifierResult.Success)
{
return(r);
}
if (!Match(card))
{
return(VerifierResult.Fail);
}
if (isUseCard)
{
if (!Game.CurrentGame.PlayerCanUseCard(source, card))
{
return(VerifierResult.Fail);
}
}
else
{
if (!Game.CurrentGame.PlayerCanPlayCard(source, card))
{
return(VerifierResult.Fail);
}
}
return(VerifierResult.Success);
}
if (cards != null && cards.Count > 1)
{
return(VerifierResult.Fail);
}
if (cards == null || cards.Count == 0)
{
return(VerifierResult.Partial);
}
if (cards[0].Place.DeckType != DeckType.Hand)
{
return(VerifierResult.Fail);
}
if (!Match(cards[0]))
{
return(VerifierResult.Fail);
}
if (isUseCard)
{
if (!Game.CurrentGame.PlayerCanUseCard(source, cards[0]))
{
return(VerifierResult.Fail);
}
}
else
{
if (!Game.CurrentGame.PlayerCanPlayCard(source, cards[0]))
{
return(VerifierResult.Fail);
}
}
return(VerifierResult.Success);
}
/// <summary>
/// 卡牌UI合法性检查
/// </summary>
/// <param name="source"></param>
/// <param name="skill"></param>
/// <param name="cards"></param>
/// <param name="targets"></param>
/// <param name="notReforging">不是重铸中，检查PlayerCanUseCard</param>
/// <returns></returns>
protected VerifierResult VerifyHelper(Player source, ISkill skill, List <Card> cards, List <Player> targets, bool isReforging)
{
ICard card;
if (skill != null)
{
CompositeCard c;
if (skill is CardTransformSkill)
{
CardTransformSkill s = skill as CardTransformSkill;
VerifierResult r = s.TryTransform(cards, targets, out c);
if (c != null && c.Type != null && !(this.GetType().IsAssignableFrom(c.Type.GetType())))
{
return(VerifierResult.Fail);
}
if (r != VerifierResult.Success)
{
return(r);
}
if (!isReforging)
{
if (!Game.CurrentGame.PlayerCanUseCard(source, c))
{
return(VerifierResult.Fail);
}
}
HoldInTemp(c.Subcards);
card = c;
}
else
{
return(VerifierResult.Fail);
}
}
else
{
if (cards == null || cards.Count != 1)
{
return(VerifierResult.Fail);
}
card = cards[0];
if (!(this.GetType().IsAssignableFrom(card.Type.GetType())))
{
return(VerifierResult.Fail);
}
if (!isReforging)
{
if (!Game.CurrentGame.PlayerCanUseCard(source, card))
{
return(VerifierResult.Fail);
}
}
HoldInTemp(cards);
}
var targetCheck = ActualTargets(source, targets, card);
if (targetCheck != null && targetCheck.Count != 0)
{
if (!isReforging)
{
if (!Game.CurrentGame.PlayerCanBeTargeted(source, targetCheck, card))
{
ReleaseHoldInTemp();
return(VerifierResult.Fail);
}
}
}
VerifierResult ret = Verify(source, card, targets);
ReleaseHoldInTemp();
return(ret);
}
bool IPlayerProxy.AskForCardUsage(Prompt prompt, ICardUsageVerifier verifier, out ISkill skill, out List <Card> cards, out List <Player> players)
{
Player p = hostPlayer;
Console.Write("I AM PLAYER {0}({1}): ", p.Id, p.Hero.Name);
cards = new List <Card>();
VerifierResult r = verifier.FastVerify(HostPlayer, null, null, null);
skill = null;
Console.Write("Ask for card usage, {0}: ", prompt);
int i = 0;
foreach (ICard card in Game.CurrentGame.Decks[p, DeckType.Hand])
{
Console.Write(" Card {0} {1}{2}{3}, ", i, card.Suit, card.Rank, card.Type.Name);
i++;
}
again:
Console.Write("Card id, -1 to trigger");
string ids = Console.ReadLine();
if (ids == null)
{
Thread.Sleep(200); cards = null; players = null; return(false);
}
int id = int.Parse(ids);
if (id < -1)
{
cards = null;
players = null;
}
else
{
if (id == -1)
{
Console.Write("Skill ID:");
ids = Console.ReadLine();
id = int.Parse(ids);
if (id >= hostPlayer.Skills.Count || ((!(hostPlayer.Skills[id] is ActiveSkill)) && (!(hostPlayer.Skills[id] is CardTransformSkill))))
{
goto again;
}
skill = hostPlayer.Skills[id];
while (true)
{
Console.Write("Card id, -1 to end");
ids = Console.ReadLine();
id = int.Parse(ids);
if (id < 0)
{
break;
}
if (id >= Game.CurrentGame.Decks[p, DeckType.Hand].Count)
{
continue;
}
cards.Add(Game.CurrentGame.Decks[p, DeckType.Hand][id]);
}
}
else
{
if (id < Game.CurrentGame.Decks[p, DeckType.Hand].Count)
{
cards.Add(Game.CurrentGame.Decks[p, DeckType.Hand][id]);
}
}
players = null;
r = verifier.FastVerify(HostPlayer, skill, cards, players);
if (r == VerifierResult.Success)
{
return(true);
}
if (r == VerifierResult.Fail)
{
Console.Write("Failed check, again? 1 yes 0 no");
ids = Console.ReadLine();
id = int.Parse(ids);
if (id == 1)
{
goto again;
}
}
}
{
players = new List <Player>();
while (true)
{
Console.WriteLine("");
Console.Write("Target player: -1 to end");
ids = Console.ReadLine();
id = int.Parse(ids);
if (id < 0)
{
break;
}
if (id > Game.CurrentGame.Players.Count)
{
Console.WriteLine("out of range");
}
else
{
players.Add(Game.CurrentGame.Players[id]);
}
r = verifier.FastVerify(HostPlayer, skill, cards, players);
if (r == VerifierResult.Partial)
{
Console.WriteLine("Require more");
}
if (r == VerifierResult.Fail)
{
Console.WriteLine("Failed check");
players.Remove(Game.CurrentGame.Players[id]);
}
}
r = verifier.FastVerify(HostPlayer, skill, cards, players);
if (r == VerifierResult.Success)
{
return(true);
}
if (r == VerifierResult.Fail)
{
Console.Write("Failed check, again? 1 yes 0 no");
ids = Console.ReadLine();
id = int.Parse(ids);
if (id == 1)
{
goto again;
}
}
players = null;
skill = null;
cards = null;
return(false);
}
}
