public AllSingleCourse()
{
InitializeComponent();
var semesterItems = SemesterService.GetCount().OrderBy(c => c.Id).ToList();
var levels = LevelService.GetCount().OrderBy(c => c.Id).ToList();
ddLevel.DataSource = levels.Select(c => c.Name);
ddlSemester.DataSource = semesterItems.ToList().Select(c => c.Name);
ddLevel.SelectedIndexChanged += ddLevel_SelectedIndexChanged;
ddlSemester.SelectedIndexChanged += ddlSemester_SelectedIndexChanged;
LevelId = LevelService.GetLevelId((string)ddLevel.SelectedValue).Id;
SemesterId = SemesterService.GetSemesterId((string)ddlSemester.SelectedValue);
ddlCourse.SelectedIndexChanged += (sender, args) =>
{
var model = CourseService.GetCourseByName((string)ddlCourse.SelectedValue);
if (model != null)
{
CourseId = model.Id;
}
};
ProcessCourseDataSourse(LevelId, SemesterId);
gridSingleStudentResult.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;
gridSingleStudentResult.AllowEditRow = true;
}
private void Awake()
{
_service = new LevelService();
_service.LoadLevel("Level1");
_movementResolver = new MovementResolver
{
LevelDataProvider = _service
};
_battlefield = new Battlefield
{
LevelDataProvider = _service,
Configs = new Dictionary <EntityType, UnitConfig>
{
{ EntityType.Player, PlayerConfig },
{ EntityType.Enemy, EnemyConfig },
{ EntityType.Obstacle, ObstaclesConfig }
}
};
_battlefield.Init();
InitPlayer();
InitOpponent();
_player.StartTurn();
}
public async Task AllowInviteExp()
{
var guildConfig = LevelService.TryGetLevelConfig(Context.Guild.Id);
if (guildConfig == null || !guildConfig.Enabled)
{
await ReplyAsync("Leveling must be enabled before enabling invite levels.");
return;
}
var guildObj = LevelService.Database.Load <LevelInviteTracker>(LevelInviteTracker.DocumentName(Context.Guild.Id));
if (guildObj == null)
{
guildObj = new LevelInviteTracker();
guildObj.GuildId = Context.Guild.Id;
guildObj.Enabled = true;
}
else
{
guildObj.Enabled = !guildObj.Enabled;
}
LevelService.Database.Store(guildObj, LevelInviteTracker.DocumentName(Context.Guild.Id));
await ReplyAsync($"Level Invites: {guildObj.Enabled}");
}
public LevelController(RoomService roomService, LevelService levelService, IMapper mapper)
{
_roomService = roomService;
_levelService = levelService;
_mapper = mapper;
}
public static Monster GetMonster(Hero fightingHero)
{
var serviceProvider4 = DIConfiguration.ConfigurazioneMonster();
MonsterService MonsterService = serviceProvider4.GetService <MonsterService>();
var monster = MonsterService.GetAllMonster(fightingHero); //mi rende i mostri con livello uguale o mini
var random = new Random();
var serviceProvider3 = DIConfiguration.ConfigurazioneLevel();
LevelService levelService = serviceProvider3.GetService <LevelService>();
var Levels = levelService.GetLivelliInfo();
int index = random.Next(monster.Count);
Monster fightingMonster = monster[index];
for (int i = 0; i < Levels.Count; i++)
{
if (Levels[i].livello == fightingMonster.level)
{
fightingMonster.lifePoint = Levels[i].lifePoint;
}
}
Console.WriteLine("Stai sfidando {0} la cui arma è {1}", fightingMonster.classPerson, fightingMonster.weapon.name);
return(fightingMonster);
}
public void Should_Create_New_Level()
{
var fakeContext = new FakeContext("CreateNewLevel");
var fakeLevel = new Level();
fakeLevel.Name = "full name";
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LevelRepository(context);
var mockValidator = new Mock <IValidator <Level> >(MockBehavior.Strict);
mockValidator
.Setup(x => x.Validate(fakeLevel))
.Returns(new FluentValidation.Results.ValidationResult());
var service = new LevelService(repository, mockValidator.Object);
var actual = service.Create(fakeLevel);
var id = actual.Id;
Assert.NotEqual(0, id);
repository.Dispose();
}
}
public void Initialize(LevelService levelService, LevelInfo levelInfo)
{
_levelService = levelService;
_levelInfo = levelInfo;
LevelList.ItemsSource = _levelService.AllWorldsLevels(levelInfo);
}
private void Awake()
{
LastTrainPos = transform.position;
_achievementsService = ServiceLocator.GetService <AchievementsService>();
_audioService = ServiceLocator.GetService <AudioService>();
_levelService = ServiceLocator.GetService <LevelService>();
_adsService = ServiceLocator.GetService <AdsService>();
_skinService = ServiceLocator.GetService <SkinService>();
_gameDataService = ServiceLocator.GetService <GameDataService>();
_uiService = ServiceLocator.GetService <UIService>();
_poolService = ServiceLocator.GetService <PoolService>();
Trains = new List <TrainController>();
spriteRenderer = GetComponent <SpriteRenderer>();
TargetPointList = TargetRail.WayPoints;
TargetPoint = TargetPointList[0].localPosition;
Trains.Add(this);
InputManager.Swipe += InputManagerOnSwipe;
_adsService.TrainRevive += ReviveTrain;
_uiService.GameRestart += ResetTrain;
_skinService.UpdateSkin(spriteRenderer);
UpdateTrainPoints();
LockControlls = _uiService.IsFirstTime;
IsFirstTime = _uiService.IsFirstTime;
}
public async Task ShowSettings()
{
var config = LevelService.TryGetLevelConfig(Context.Guild.Id);
if (config == null)
{
await ReplyAsync("Leveling has not been enabled in this server.");
return;
}
var responses = config.RewardRoles.OrderByDescending(x => x.LevelRequirement).Select(x =>
{
var role = Context.Guild.GetRole(x.RoleId);
if (role == null)
{
return(null);
}
return($"{x.LevelRequirement} | {role.Mention}");
}).Where(x => x != null).ToList();
var message = $"Enabled: {config.Enabled}\n" +
$"Multiple Role rewards: {config.MultiRole}\n" +
$"Reply with level ups: {config.ReplyLevelUps}\n" +
$"Restriction Mode: {config.RestrictionMode}\n" +
$"Restricted Channels:" + string.Join("\n", config.RestrictedChannels.Select(x => Context.Guild.GetTextChannel(x)?.Name ?? $"DELETED: [{x}]")) +
"\nNOTE: If there are deleted channels you can remove them by running the clearchannels command\n" +
$"Role Rewards: \n{(responses.Any() ? string.Join("\n", responses) : "N/A" )}\n";
await ReplyAsync("", false, message.QuickEmbed());
}
public static MoveLevelResult Show(LevelService levelService, WorldService worldService, WorldInfo hostWorld, LevelInfo parentLevel)
{
MoveLevelResult moveLevelResult = null;
MoveLevelWindow window = new MoveLevelWindow(levelService, worldService, hostWorld, parentLevel);
window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
window.ShowDialog();
if (window.DialogResult == true)
{
moveLevelResult = new MoveLevelResult();
if (window.ParentLevel != null)
{
moveLevelResult.InfoNode = window.ParentLevel;
}
else
{
moveLevelResult.InfoNode = window.HostWorld;
}
return(moveLevelResult);
}
return(moveLevelResult);
}
public async Task ResetLeaderboard(SocketGuildUser user)
{
if (user.Hierarchy >= (Context.User as SocketGuildUser).Hierarchy)
{
if (user.Id != Context.User.Id)
{
await ReplyAsync("You cannot reset the level of a user with higher permissions than you.");
return;
}
}
var levelUser = LevelService.GetLevelUser(Context.Guild.Id, user.Id);
if (levelUser.Item1 != null)
{
var profile = levelUser.Item1;
profile.UserLevel = 0;
profile.UserXP = 0;
LevelService.Database.Store(profile, LevelUser.DocumentName(profile.UserId, profile.GuildId));
await ReplyAsync("User has been reset.");
}
else
{
await ReplyAsync("User does not exist in the level database.");
}
}
public void OnNavigatedTo(INavigationParameters parameters)
{
LessonID = int.Parse(parameters["LessonID"].ToString());
LevelID = new LevelService().GetLevelIDByLessonID(LessonID);
List <Word> wordList = new WordService().GetWordListByLessonID(LessonID, LevelID);
ObservableCollection <Word> wordCollection = new ObservableCollection <Word>();
foreach (Word word in wordList)
{
word.BackgroundColor = "#5389d6";
word.BorderColor = "#64aeff";
wordCollection.Add(word);
}
Words = wordCollection;
CurrentLevel = "- Level: " + new LevelService().GetLevelNameByLevelID(LevelID);
CurrentLessonName = "- Bài học: " + new LessonService().GetLessonNameByLessonID(LessonID);
Title = "Cấp độ " + new LevelService().GetLevelNameByLevelID(LevelID) + " - " + new LessonService().GetLessonNameByLessonID(LessonID);
CurrentMeaning = Words.ElementAt(0).Mean;
CurrentKunyomi = Words.ElementAt(0).Onyomi;
CurrentOnyomi = Words.ElementAt(0).Kunyomi;
CurrentExample = Words.ElementAt(0).Example;
CurrentKanji = Words.ElementAt(0).Kanji;
SelectedWord = Words.ElementAt(0);
Words.ElementAt(0).BackgroundColor = "#ff8410";
Words.ElementAt(0).BorderColor = "#ffb479";
}
public async Task AddRole(IRole role, int level)
{
var config = LevelService.TryGetLevelConfig(Context.Guild.Id);
if (config == null || !config.Enabled)
{
await ReplyAsync("You must enable leveling before editing it's settings.");
return;
}
//Remove the role if it already exists in the rewards
config.RewardRoles = config.RewardRoles.Where(x => x.RoleId != role.Id).ToList();
if (config.RewardRoles.Any(x => x.LevelRequirement == level))
{
await ReplyAsync("There can only be one role per level.");
return;
}
config.RewardRoles.Add(new LevelConfig.LevelReward
{
RoleId = role.Id,
LevelRequirement = level
});
LevelService.Database.Store(config, LevelConfig.DocumentName(Context.Guild.Id));
await ReplyAsync($"Role Added");
}
public async Task Rank(SocketGuildUser user = null)
{
if (user == null)
{
user = Context.User as SocketGuildUser;
}
var config = LevelService.GetLevelUser(Context.Guild.Id, user.Id);
if (config == null || config.Item2 == null || !config.Item2.Enabled)
{
await ReplyAsync("Leveling is not enabled in this server.");
return;
}
var users = LevelService.Database.Query <LevelUser>(x => x.GuildId == Context.Guild.Id).OrderByDescending(x => x.UserXP).ToList();
int rank = users.IndexOf(users.Where(x => x.UserId == user.Id).FirstOrDefault()) + 1;
var embed = new EmbedBuilder()
{
Title = "Level Info",
Author = new EmbedAuthorBuilder()
{
IconUrl = user.GetAvatarUrl() ?? user.GetDefaultAvatarUrl(),
Name = user.ToString()
},
Description = $"**Current Level:** {config.Item1.UserLevel}\n" +
$"**Current XP:** {config.Item1.UserXP}\n" +
$"**XP To Next Level:** {LevelService.RequiredExp(config.Item1.UserLevel + 1) - config.Item1.UserXP}\n" +
$"**Rank:** {rank}/{users.Count}"
};
await ReplyAsync("", false, embed.Build());
}
public void Init()
{
_user = UserSession();
_repository = new UowRepository();
_levelService = new LevelService(_user, _repository);
_sbError = new StringBuilder("");
}
private void _ProjectPanel_ProjectLoaded(Project project)
{
_project = project;
_projectService = new ProjectService(new ErrorService(), project);
_graphicsService = new GraphicsService(_errorService, project);
_levelService = new LevelService(_errorService, project);
_palettesService = new PalettesService(_errorService, project);
_worldService = new WorldService(_errorService, project);
_tileService = new TileService(_errorService, project);
_textService = new TextService(_errorService, project);
_clipBoardService = new ClipBoardService();
_romService = new RomService(_errorService, _graphicsService, _palettesService, _tileService, _levelService, _worldService, _textService);
_gameObjectService = new GameObjectService(_errorService, project);
_levelService.LevelUpdated += _levelService_LevelUpdated;
_worldService.WorldUpdated += _worldService_WorldUpdated;
List <WorldInfo> worldInfos = new List <WorldInfo>();
worldInfos.AddRange(project.WorldInfo);
worldInfos.Add(project.EmptyWorld);
FilePanel.Initialize(_levelService, _worldService);
SplashText.Visibility = Visibility.Collapsed;
_config.LastProjectPath = _project.DirectoryPath + "\\" + _project.Name + ".json";
}
public void Init(GameStateUpdateService updateService, LevelService levelService, Transform parent, UnitLevelModel model, UnitView view, Canvas canvas)
{
_updateService = updateService;
_levelService = levelService;
_model = model;
_view = view;
_oldHealth = _model.State.Health;
_levelService.OnUnitSelected += OnUnitSelected;
_levelService.OnUnitCanTurn += OnUnitCanTurn;
_updateService.OnStateUpdated += OnStateUpdated;
_updateService.AddHandler <AttackCommand>(OnAttackUnit);
_updateService.AddHandler <KillUnitCommand>(OnKillUnit);
SelectView();
UpdateSelection(false);
UpdateInteractable(model.IsPlayerUnit);
UpdateHealth();
transform.SetParent(parent, false);
_view.transform.SetParent(canvas.transform, false);
_view.transform.position = Camera.main.WorldToScreenPoint(transform.position);
var distance = transform.position.z - Camera.main.transform.position.z;
_view.UpdateDistance(distance);
_view.SelectColor(model.IsPlayerUnit);
}
public void Initialize(LevelService levelService, WorldInfo worldInfo)
{
_levelService = levelService;
_worldInfo = worldInfo;
LevelList.ItemsSource = _levelService.AllLevels();
}
private void btnSave_Click(object sender, EventArgs e)
{
lblError.Text = "";
if (nddScore.Value <= 0)
{
lblError.Text = @"Score is required";
return;
}
if ((nddScore.Value % 1) != 0)
{
lblError.Text = @"Score is whole number";
return;
}
try
{
MatricNumber = AspNetUserService.GetStudentId((string)ddlMatricNumber.SelectedValue);
var studentDetails = $"{MatricNumber.FirstName} {MatricNumber.LastName}({MatricNumber.MatricNumber})";
var level = LevelService.GetItem(LevelId);
if (level.SectionModels != null && level.SectionModels.Count > 0)
{
var message = $@"Result Details {Environment.NewLine}Matric Number: {studentDetails}{Environment.NewLine}Course: {(string)ddlCourse.SelectedValue}{Environment.NewLine}Result: {nddScore.Value}";
var dialogResult = MessageBox.Show(message, @"Result Details", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (dialogResult == DialogResult.OK)
{
var cId = CourseService.GetCourseByName((string)ddlCourse.SelectedValue).Id;
var courseWithResult = ResultService.CanSaveResult(MatricNumber.Id, cId);
if (courseWithResult != null)
{
MessageBox.Show(@"Student already have result", "Upload Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var result = new ResultModel
{
SectionId = level.SectionModels.FirstOrDefault().Id,
CourseId = cId,
StudentId = MatricNumber.Id,
Score = int.Parse(nddScore.Value.ToString()),
CreatedAt = DateTime.UtcNow
};
ResultService.Create(result, 0);
MessageBox.Show($@"Result of {studentDetails} is saved", "Upload successfull", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(@"Ensure that LEVEL selected has a SESSION attached to it.", "Upload Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception ex)
{
_logger.Error("Error Message: " + ex.Message.ToString(), ex);
MessageBox.Show($@"Message: {ex.Message}{Environment.NewLine}Stack Message: {ex.StackTrace}", $@"Error Message from {typeof(SingleStudentSemesterResult)}");
}
}
public void GetLevelsTest()
{
var expected = SetupLevels();
var levelService = new LevelService(_mockUnitOfWork.Object, _mockLevelRepository.Object);
var result = levelService.GetLevels();
CollectionAssert.AreEqual(result.ToList(), expected);
}
public void Initialize(LevelService levelService, WorldService worldService)
{
_levelService = levelService;
_worldService = worldService;
_levelService.LevelUpdated += _levelService_LevelUpdated;
_levelService.LevelsUpdated += _levelService_LevelsUpdated;
BuildTree();
}
public LevelQuestionsViewModel(int levelIdParam)
{
levelId = levelIdParam;
_levelService = new LevelService();
_levelQuestionService = new LevelQuestionsService();
LoadQuestions();
EndLevel = new Command(endLevel);
}
public async Task ToggleLevelingAsync()
{
var config = LevelService.GetOrCreateLevelConfig(Context.Guild.Id);
config.Enabled = !config.Enabled;
LevelService.Database.Store(config, LevelConfig.DocumentName(Context.Guild.Id));
await ReplyAsync($"Leveling Enabled: {config.Enabled}");
}
private HeroService()
{
SkillService = Skill.SkillService.GetInstance();
ItemService = Item.ItemService.GetInstance();
ClassService = Class.ClassService.GetInstance();
LevelService = LevelService.GetInstance();
StatusService = StatusService.GetInstance();
}
public RankController(RankService rankService, UserService userService, LevelService levelService)
{
_rankService = rankService;
_userRank = new List <User>();
_userStatsDto = new List <UserStatsDto>();
_userService = userService;
_levelService = levelService;
}
public LevelServiceTest()
{
_fakeContext = new FakeContext("LevelTestes");
_fakeContext.FillWithAll();
_contexto = new CentralErroContexto(_fakeContext.FakeOptions);
_levelService = new LevelService(_contexto);
}
public async Task ToggleWhitelist()
{
var config = LevelService.GetOrCreateLevelConfig(Context.Guild.Id);
config.RestrictionMode = LevelConfig.LevelRestrictionType.Whitelist;
LevelService.Database.Store(config, LevelConfig.DocumentName(Context.Guild.Id));
await ReplyAsync($"Leveling will now be restricted to channels added with the `addchannel` command");
}
public void Should_Return_Right_User_When_Find_By_Id(int id)
{
var level = _fakeContext.GetFakeData <Level>().Find(x => x.IdLevel == id);
var service = new LevelService(_contexto);
var atual = service.FindByIdLevel(level.IdLevel);
Assert.Equal(level, atual, new LevelIdComparer());
}
public Menu(bool dispose = true)
{
InitializeComponent();
UserProfile.CurrentForm = this;
this.levelService = new LevelService();
this.hintService = new HintService();
this.userService = new UserService();
this.dispose = dispose;
}
public SendRequest(bool dispose = true)
{
InitializeComponent();
userService = new UserService();
levelService = new LevelService();
gameSessionService = new GameSessionService();
this.dispose = dispose;
UserProfile.CurrentForm = this;
}
public void genarateRulesForLevelService(LevelService levelService)
{
IEnumerable<string> worldNames = levelService.getSinglePlayerWorldNames();
levelRequirement = 0;
firstBoss = true;
mediumLevelResults = 0;
foreach (string worldName in worldNames)
{
IEnumerable<LevelRecord> levelsInWorld = levelService.getLevelsInWorld(worldName);
levelTypeCounter = 1;
foreach (LevelRecord level in levelsInWorld)
{
if(levelTypeCounter==1 || level.isMultiplayer)
{
level.setRequiredRewards(0);
}
else
{
level.setRequiredRewards(levelRequirement);
}
if (levelTypeCounter == worldPartSize)
{
generateRulesForBossLevel(level);
}
else if (levelTypeCounter % stressLevelFrequency == 0)
{
generateRulesForStressLevel(level);
} else
{
generateRulesForNormalLevel();
}
}
}
}
void setupLevelService()
{
testSubject = new LevelService();
List<LevelRecord> levelRecordList = new List<LevelRecord>();
LevelRecord testLevelRecordWorld3;
levelRecordList.AddRange(generateCompleteWorld(0, 0,false));
levelRecordList.AddRange(generateCompleteWorld(1, 0,false));
levelRecordList.AddRange(generateCompleteWorld(2, 0,false));
levelRecordList.AddRange(generateCompleteWorld(3, 0,true));
testSubject.levelList = levelRecordList;
testSubject.levelListOffset = levelListOffset;
}