public async Task GetCategoryById()
{
try
{
// Arrange
CategoryController controller = new CategoryController();
controller.Request = new HttpRequestMessage();
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
// Act
ChallengeTypeProvider _ChallengeTypeProvider = new ChallengeTypeProvider();
var testProducts = await _ChallengeTypeProvider.GetById(1) as ChallengeType;
string testproduct = testProducts.ChallengeTypeTitle;
// Act
var response = await controller.GetCategoryById(1) as HttpResponseMessage;
ObjectContent objContent = response.Content as ObjectContent;
ChallengeType picklistItem = objContent.Value as ChallengeType;
string icount = picklistItem.ChallengeTypeTitle;
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(testproduct, icount);
}
catch (Exception ex)
{
throw ex;
}
}
public void ChangeChallengeType(ChallengeType chtype, byte newDifficulty)
{
challengeType = chtype;
difficultyClass = newDifficulty;
isPassed = false;
isHidden = true;
}
private async Task OnChallengeTypeSelectedAnimations(ChallengeType selectedChallengeType)
{
//var notSelected = _challengeTypesIcons.Where(x => x.ChallengeType != selectedChallengeType);
//var selected = _challengeTypesIcons.First(x => x.ChallengeType == selectedChallengeType);
//await Task.WhenAll
//(
// notSelected.Select(x => x.Image.FadeTo(0, Configuration.AnimationSpeed, Easing.SinIn))
//);
////double imageY = (_challengeTypesIconsLayout.Parent.Parent as View).Y + (_challengeTypesIconsLayout.Parent as View).Y + _challengeTypesIconsLayout.Y + _mainLayoutMargin + ((selected.Image.Height + _challengeTypesIconsLayout.RowSpacing) * (int)selectedChallengeType);
//double imageY = (_challengeTypesIconsLayout.Parent.Parent as View).Y + (_challengeTypesIconsLayout.Parent as View).Y + _challengeTypesIconsLayout.Y + ((selected.Image.Height + _challengeTypesIconsLayout.RowSpacing) * (int)selectedChallengeType);
//int distanceToTop = -(int)Math.Ceiling(imageY - (130 - 50));
//ChallengeTypeIconSize = new Size(selected.Image.Width, selected.Image.Height);
await Task.WhenAll
(
//emotionalIcon.DisappearLeft(Configuration.AnimationSpeed),
base.OnNextButtonPressedAnimations()
//selected.Image.TranslateTo(0, distanceToTop, Configuration.AnimationSpeed, Easing.CubicInOut)
);
}
public async Task <ActionResult <ChallengeType> > PostChallengeType([FromBody] ChallengeType challengeType)
{
_context.ChallengeType.Add(challengeType);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetChallengeType", new { id = challengeType.Id }, challengeType));
}
//private void GameOver ( ) {
// targetArea.Stop( );
// playing = false;
// stageProgressBar.Value = 1;
// restartButton.Visible = true;
// leaderboardButton.Visible = true;
//}
private void ChallengeProgressCallback(bool isHit, ChallengeType type)
{
if (isHit)
{
swoosh.Appear( );
float damage = Manager.State.Damage;
textAnimations.Add(new FadeTextAnimation(new Label(this, new Container(new Margin(0, 0, map.MobPosition.Y - 0.075f, 0), MarginType.Absolute, anchor: Position.Center | Position.Top, dock: Position.Right | Position.Top, relative: damageLabelAligner), 0.05f, damage.ToString( ), alignment: Label.TextAlignment.Center), 0.05f, 0.75f));
if ((mobs[0].Health -= damage) < 0)
{
mobs[0].Die(null);
Next( );
}
healthLeftBar.Value = mobs[0].Health;
multiplier += 0.2f;
}
else
{
// heartViewer.Active--;
// if (heartViewer.Active == 0) {
// GameOver( );
// }
multiplier -= 0.5f;
}
}
public void setBestLevel(int level,ChallengeType challengeType){
if(challengeType==ChallengeType.TIME){
if(PlayerPrefs.GetInt("bestLevelTime")==null){
bestLevel=PlayerPrefs.GetInt("bestLevelTime");
}else{
bestLevel=1;
}
}
if(challengeType==ChallengeType.ACURACY){
if(PlayerPrefs.GetInt("bestLevelAcuracy")==null){
bestLevel=PlayerPrefs.GetInt("bestLevelAcuracy");
}else{
bestLevel=1;
}
}
if(level>bestLevel){
bestLevel=level;
if(challengeType==ChallengeType.TIME){
PlayerPrefs.SetInt("bestLevelTime",bestLevel);
}
if(challengeType==ChallengeType.ACURACY){
PlayerPrefs.SetInt("bestLevelAcuracy",bestLevel);
}
}
}
public void SetPoints(ref LevelDataToSave l, ChallengeType ct)
{
LevelDataToSave prevLevel = infoType[ct].currentLevel - 1 >= 0 ? infoType[ct].levels[infoType[ct].currentLevel - 1] : infoType[ct].levels[0];
l.maxPoints = prevLevel.amountWords * (3 - prevLevel.bestTimeRespond) * prevLevel.difficulty + avgWordScreen * -(prevLevel.difficulty * 2 / 100) + prevLevel.restTimeLastLevel / 2;
l.minPoints = prevLevel.amountWords * (3 - prevLevel.worstTimeRespond) * prevLevel.difficulty + avgWordScreen * -(prevLevel.difficulty * 2 / 100) + prevLevel.restTimeLastLevel / 2;
}
public FrontendBehavior(StepType type, ChallengeType challengeType, PollingAction polling)
{
Type = type;
ActionType = ActionType.Polling;
Polling = polling;
ChallengeType = challengeType;
}
public ChallengeField(ChallengeType i_type, byte i_difficulty)
{
challengeType = i_type;
difficultyClass = i_difficulty;
isHidden = true;
isPassed = false;
}
public void AddData(ChallengeType ct, LevelDataToSave l)
{
string text = JsonUtility.ToJson(l);
byte[] vs = new UTF8Encoding(true).GetBytes(text);
files[ct].Write(vs, 0, text.Length);
}
private int GetCurrentSituationMissingPoints(ChallengeType challengeType, int goal)
{
int result = 0;
switch (challengeType)
{
case ChallengeType.CadastrarClientes:
result = goal - registerPoints;
if (result < 0)
{
result = 0;
}
return(result);
case ChallengeType.ConvidarFloresAliadas:
result = goal - invitePoints;
if (result < 0)
{
result = 0;
}
return(result);
case ChallengeType.NumeroVendas:
result = goal - salesPoints;
if (result < 0)
{
result = 0;
}
return(result);
default: return(0);
}
}
public FrontendBehavior(StepType type, ChallengeType challengeType, FrontendBehavior nextBehavior)
{
Type = type;
ActionType = ActionType.GoToNext;
ChallengeType = challengeType;
NextBehavior = nextBehavior;
}
public static void OnLevelLoaded()
{
if (CurrentChallenge != ChallengeType.NONE)
{
//ETGModConsole.Log("Challenge was not null!");
PlayerController player1 = GameManager.Instance.PrimaryPlayer;
if (player1 == null)
{
ETGModConsole.Log("ERRA PLAYA NULLA");
}
PlayerController player2 = null;
if (GameManager.Instance.SecondaryPlayer != null)
{
player2 = GameManager.Instance.SecondaryPlayer;
}
if (GameStatsManager.Instance.IsRainbowRun)
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Played Rainbow Run</color>", false);
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Played Rainbow Run", 4f);
CurrentChallenge = ChallengeType.NONE;
}
else if (player1.CharacterUsesRandomGuns || (player2 && player2.CharacterUsesRandomGuns))
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Played Blessed Run</color>", false);
CurrentChallenge = ChallengeType.NONE;
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Played Blessed Run", 4f);
}
else if (player1.characterIdentity == PlayableCharacters.Gunslinger || (player2 && player2.characterIdentity == PlayableCharacters.Gunslinger))
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Played as Gunslinger</color>", false);
CurrentChallenge = ChallengeType.NONE;
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Played as Gunslinger", 4f);
}
else if (player1.characterIdentity == PlayableCharacters.Eevee || (player2 && player2.characterIdentity == PlayableCharacters.Eevee))
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Played as Paradox</color>", false);
CurrentChallenge = ChallengeType.NONE;
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Played as Paradox", 4f);
}
else if (GameManager.Instance.CurrentGameMode == GameManager.GameMode.SHORTCUT)
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Took a Shortcut</color>", false);
CurrentChallenge = ChallengeType.NONE;
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Took a Shortcut", 4f);
}
else if (GameManager.Instance.CurrentGameMode == GameManager.GameMode.BOSSRUSH)
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Entered Bossrush</color>", false);
CurrentChallenge = ChallengeType.NONE;
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Entered Bossrush", 4f);
}
else if (GameManager.Instance.InTutorial)
{
ETGModConsole.Log("<color=#ff0000ff>Challenge Voided: Entered Tutorial</color>", false);
CurrentChallenge = ChallengeType.NONE;
TextBubble.DoAmbientTalk(player1.transform, new Vector3(1, 2, 0), "Challenge Voided: Entered Tutorial", 4f);
}
}
}
void OnApplicationQuit()
{
for (int i = 0; i < (int)ChallengeType.Count; i++)
{
ChallengeType ct = ((ChallengeType)i);
files[ct].Close();
}
}
public static long Solve2(ChallengeType input)
{
var c = new Calculator();
c.AddOp('+', (a, b) => a + b, 1);
c.AddOp('*', (a, b) => a * b);
return(input.Select(l => c.Evaluate(l)).Sum());
}
public FrontendBehavior(StepType type, ChallengeType challengeType, CallAction callback,
FrontendBehavior alternativeBehavior = null)
{
Type = type;
ActionType = ActionType.Callback;
Callback = callback;
ChallengeType = challengeType;
AlternativeBehavior = alternativeBehavior;
}
public static FrontendBehavior CreateSuccessFinish(ChallengeType challengeType)
{
return(new()
{
Type = StepType.Success,
ChallengeType = challengeType,
ActionType = ActionType.Finish
});
}
public static long Solve2(ChallengeType seed)
{
for (int i = 0; i < 50; ++i)
{
seed = LookAndSay(seed);
}
return(seed.Length);
}
public static EventType ToEventType(this ChallengeType challengeType)
{
return(challengeType switch
{
ChallengeType.Register => EventType.Register,
ChallengeType.Login => EventType.Login,
ChallengeType.Link => EventType.Link,
ChallengeType.Recover => EventType.Recover,
_ => EventType.Unknown
});
public ChallengeData(ChallengeType Type, UInt32 Threshold, ChallengeFlags Flags, UInt32 Interval, dynamic Value1, dynamic Value2, dynamic Value3)
{
this.Type = Type;
this.Threshold = Threshold;
this.Flags = Flags;
this.Interval = Interval;
this.Value1 = Value1;
this.Value2 = Value2;
this.Value3 = Value3;
}
// Token: 0x0600080D RID: 2061 RVA: 0x00030620 File Offset: 0x0002E820
public void ChangeChallengeProgression(ChallengeType type, int value)
{
for (int i = 0; i < this.currentChallenges.Count; i++)
{
if (this.currentChallenges[i].myChallenge.uniqueChallengeID == this.challengeList.listOfChallenges[(int)type].uniqueChallengeID)
{
this.currentChallenges[i].AddProgression(value);
}
}
}
public ChallengeData()
{
Type = new ChallengeType();
Threshold = new UInt32();
Flags = new ChallengeFlags();
Interval = new UInt32();
Value1 = new Int16();
Value2 = new Int16();
Value3 = new Int32();
}
public ChallengeData(string name, string description, ChallengeType type)
{
Name = name;
Description = description;
Type = type;
if (type == ChallengeType.Progressable)
{
subChallenges = new List<SubChallengeData>();
}
}
// prefix param is workaround for partial flow
public Uri GetChallengeUrl(string context, ChallengeType challengeType, string prefix = null)
{
var action = challengeType switch
{
ChallengeType.Link => "link",
ChallengeType.Recover => "recover",
_ => $"challenge{prefix}"
};
return(GetBaseActionUrl(context, action));
}
private Image ConfigureOptionButton(ChallengeType challengeType, Size?size = null)
{
Image imageButton = FormsHelper.ConfigureImageButton($"{ challengeType.ToString().ToLower() }.png", (s, e) => { var t = OnChallengeTypeSelected(challengeType); }, size);
//imageButton.WidthRequest = 100;
imageButton.HorizontalOptions = LayoutOptions.Center;
imageButton.VerticalOptions = LayoutOptions.FillAndExpand;
imageButton.Aspect = Aspect.AspectFit;
return(imageButton);
}
public void setupCurrentChallenge(string _type)
{
try
{
_currentType = (ChallengeType)System.Enum.Parse(typeof(ChallengeType), _type);
}
catch (UnityException _err)
{
_currentType = ChallengeType.NotDefined;
}
}
void Start()
{
saveLoad = SaveLoad.Instance;
for (int i = 0; i < (int)ChallengeType.Count; i++)
{
infoType.Add((ChallengeType)i, new L());
}
//
challengeType = ChallengeType.ZCS;
}
/// <summary>
/// Defines file properties
/// </summary>
protected void _SetProperties()
{
Property.ComputeValueDelegate wpCountDelegate = () => CheckpointCount.ToString();
Property.ComputeValueDelegate modeDelegate = () => ChallengeMode.ToString();
Property.ComputeValueDelegate typeDelegate = () => ChallengeType.ToString();
Property.ComputeValueDelegate nameDelegate = () => TrackName;
Properties.Add(new Property("Track name", "DFE/IGE", nameDelegate));
Properties.Add(new Property("Challenge mode", "DFE/IGE", modeDelegate));
Properties.Add(new Property("Challenge type", "DFE/IGE", typeDelegate));
Properties.Add(new Property("Waypoint count", "DFE/IGE", wpCountDelegate));
}
public static UnityEngine.Rect GetChallengeIconRect(ChallengeType ctype)
{
switch (ctype)
{
case ChallengeType.PersistenceTest: return(UIController.GetIconUVRect(Icons.PersistenceIcon));
case ChallengeType.SurvivalSkillsTest: return(UIController.GetIconUVRect(Icons.SurvivalSkillsIcon));
case ChallengeType.PerceptionTest: return(UIController.GetIconUVRect(Icons.PerceptionIcon));
case ChallengeType.SecretKnowledgeTest: return(UIController.GetIconUVRect(Icons.SecretKnowledgeIcon));
case ChallengeType.IntelligenceTest: return(UIController.GetIconUVRect(Icons.IntelligenceIcon));
case ChallengeType.TechSkillsTest: return(UIController.GetIconUVRect(Icons.TechSkillsIcon));
case ChallengeType.Treasure: return(UIController.GetIconUVRect(Icons.TreasureIcon));;
case ChallengeType.QuestTest: return(UIController.GetIconUVRect(Icons.QuestMarkerIcon));
case ChallengeType.CrystalFee: return(UIController.GetIconUVRect(Icons.EnergyCrystal));
case ChallengeType.AscensionTest: return(UIController.GetIconUVRect(Icons.AscensionIcon));
case ChallengeType.Impassable:
case ChallengeType.NoChallenge:
return(UnityEngine.Rect.zero);
case ChallengeType.PuzzlePart: return(UIController.GetIconUVRect(Icons.PuzzlePart)); // colouring?
case ChallengeType.FoundationPts: return(UIController.GetIconUVRect(Icons.FoundationRoute));
case ChallengeType.CloudWhalePts: return(UIController.GetIconUVRect(Icons.CloudWhaleRoute));
case ChallengeType.EnginePts: return(UIController.GetIconUVRect(Icons.EngineRoute));
case ChallengeType.PipesPts: return(UIController.GetIconUVRect(Icons.PipesRoute));
case ChallengeType.CrystalPts: return(UIController.GetIconUVRect(Icons.CrystalRoute));
case ChallengeType.MonumentPts: return(UIController.GetIconUVRect(Icons.MonumentRoute));
case ChallengeType.BlossomPts: return(UIController.GetIconUVRect(Icons.BlossomRoute));
case ChallengeType.PollenPts: return(UIController.GetIconUVRect(Icons.PollenRoute));
case ChallengeType.ExitTest: return(UIController.GetIconUVRect(Icons.GreenArrow));
default:
return(UIController.GetIconUVRect(Icons.Unknown));
}
}
List <ChallengeContainer> containsEnumType(ChallengeType type)
{
List <ChallengeContainer> challengeList = new List <ChallengeContainer>();
foreach (ChallengeContainer c in GetComponent <ChallengeBuilder>().challenges)
{
if (c.challenge.type == type)
{
challengeList.Add(c);
}
}
return(challengeList);
}
public void UpdateData(GameMode mode, ChallengeType type, bool state, int level, ref LevelDataToSave saveData)
{
save = saveData;
Mode = mode;
this.type = type;
this.state = state;
save.level = level;
if (!state)
{
levelText.color = Color.red;
}
levelText.text = save.level + "";
}
//protected override void OnAppearing()
//{
// emotionalIcon = FormsHelper.ConfigureImageButton($"{ emotionalStatus.ToString().ToLower() }.png", null, SelectEmotionalStatusPage.EmotionalIconSize); // new Size(85, 85));
// //emotionalIcon.VerticalOptions = LayoutOptions.Center;
// //emotionalIcon.Margin = new Thickness(0, 20, 0, 0);
// //_youHaveChosenContent.Children.Add(emotionalIcon);
// //_mainLayout.Children.Add(emotionalIcon, new Rectangle(0.5, 130, 87.7143, 87.7143), AbsoluteLayoutFlags.XProportional);
// _mainLayout.Children.Add(emotionalIcon, new Rectangle(0.5, 130, SelectEmotionalStatusPage.EmotionalIconSize.Width, SelectEmotionalStatusPage.EmotionalIconSize.Height), AbsoluteLayoutFlags.XProportional);
// base.OnAppearing();
//}
private async Task OnChallengeTypeSelected(ChallengeType selectedChallengeType)
{
foreach (ChallengeTypeIcon gti in _challengeTypesIcons)
{
gti.Image.IsEnabled = false;
}
await OnChallengeTypeSelectedAnimations(selectedChallengeType).ContinueWith(async(t) =>
{
await Task.Delay(1);
ChallengeTypeSelected?.Invoke(selectedChallengeType);
});
}
public ChallengeProgress(ChallengeType type)
{
this.type = type;
switch (type)
{
case ChallengeType.Binary:
isDone = false;
break;
case ChallengeType.Progressable:
subChallengesProgress = new List<SubChallengeProgress>();
break;
case ChallengeType.ProgressableNoSubs:
isDone = false;
progress = 0;
break;
}
}
public bool IsChallengeValid(string challenge, string userInput, ChallengeType challengeType)
{
string expected;
switch (challengeType)
{
case ChallengeType.CharactersOnly:
expected = this.GetSecurityString(challenge, char.IsLetter, x => true);
break;
case ChallengeType.EvenNumbers:
expected = this.GetSecurityString(challenge, char.IsDigit, CharToIntIsEven);
break;
case ChallengeType.OddNumbers:
expected = this.GetSecurityString(challenge, char.IsDigit, CharToIntIsOdd);
break;
default:
throw new ArgumentOutOfRangeException("challengeType");
}
return expected.ToLower() == userInput.ToLower();
}
void Awake(){
uiManager=UIManager._instance;
challengeType=(ChallengeType)Enum.Parse(typeof(ChallengeType),PlayerPrefs.GetString("challengeType"));
print("Challenge type is : " + challengeType);
if(challengeType==ChallengeType.ACURACY){
uiManager.hideTime();
}
}
/// <summary>
/// Creates a number of random challenges by reading in from the Challenge_Definitions SQL table.
/// </summary>
/// <param name="type">Type of challenges desired (Daily/Weekly/Monthly).</param>
/// <param name="count">Number of challenges needing to be created.</param>
/// <returns></returns>
public static List<Challenge> GenerateRandomChallenges(ChallengeType type, int count)
{
try
{
using (SqlConnection connection = ConnectionManager.GetConnection())
{
List<Challenge> challenges = new List<Challenge>();
var data = new ActivEarthDataProvidersDataContext(connection);
List<Challenge> templates = (from c in data.ChallengeDefinitionDataProviders
where (c.challenge_type == (byte)type && c.persistent == false)
select new Challenge()
{
IsPersistent = c.persistent,
StatisticBinding = (Statistic)c.statistic,
Requirement = (float)c.requirement,
Reward = c.reward,
Description = c.description,
Name = (c.name == null ? String.Empty : c.name),
ImagePath = c.image_path
}).ToList();
Random rand = new Random();
while (challenges.Count < count)
{
int i = rand.Next(templates.Count);
if (!challenges.Contains(templates[i]))
{
string formatString = StatisticInfoDAO.GetStatisticFormatString(templates[i].StatisticBinding);
string requirementString = templates[i].Requirement.ToString(formatString);
templates[i].Description = String.Format(templates[i].Description, requirementString);
challenges.Add(templates[i]);
}
}
return challenges;
}
}
catch (Exception)
{
return null;
}
}
