public async void Start()
{
try
{
var courseList = await F****r.GetCourseList(0, 100);
if (courseList == null || courseList.List == null || courseList.List.Count == 0)
{
throw new Exception("not implemented");
}
this.courseList = courseList;
await F****r.GetCourseAppendix(courseList.List[0]);
if (courseList.List[0].Appendix == null)
{
throw new Exception("获取课程附加信息时出错, 请重新开启程序!");
}
this.TaskForWork.LimitIntegral = courseList.List[0].Appendix.MaxExamIntegral;
DoWork();
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
public async override void DoWork()
{
try
{
if (this.TaskStatus == TaskStatus.Stopping)
{
TaskStatus = TaskStatus.Stopped;
TaskForWork.TaskStatus = TaskStatus.Stopped;
return;
}
Arena = await F****r.GetArena();
if (Arena == null)
{
throw new Exception("error");
}
if (await F****r.JoinArena(Arena) && Arena.GroupId != "")
{
await GetArenaBothSide();
StartRound(0);
}
else
{
DoWork();
}
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
private async void OnReply(object sender, ElapsedEventArgs args, int roundIndex)
{
try
{
var round = Arena.Rounds[roundIndex];
var myself = Arena.BothSides.FindIndex(s => s.Username == F****r.Worker.User.UserName);
var rival = myself ^ 1;
var myRight = round.AnswerResult[myself].Where(s => s == 1).Count();
var rivalRight = round.AnswerResult[rival].Where(s => s == 1).Count();
string answer;
if (myRight >= rivalRight + 2)
{
answer = round.Question.Answers == "A" ? "B" : "A";
}
else
{
answer = round.Question.Answers;
}
if (await F****r.SubmitQuestion(Arena, round, answer.Replace(";", ",")))
{
StartRound(++roundIndex);
}
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
public async override void DoWork()
{
try
{
Random random = new Random();
int id = random.Next(0, courseList.List.Count - 1);
var course = courseList.List[id];
var examList = await F****r.GetExamList(course);
if (examList == null || examList.Count == 0)
{
DoWork();
return;
}
DoExam(course, examList.List[0], examList);
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
public async void DoExam(Course course, Exam exam, ExamList examList)
{
try
{
if (this.TaskStatus == TaskStatus.Stopping)
{
TaskStatus = TaskStatus.Stopped;
return;
}
this.Exam = exam;
await F****r.GetExamDetail(exam);
if (exam.ExamDetail == null || exam.ExamDetail.AllowExam == false)
{
var index = examList.List.IndexOf(exam);
if (index == examList.Count - 1)
{
DoWork();
}
else
{
index++;
DoExam(course, examList.List[index], examList);
}
}
else
{
var integral = await StartExam(exam);
TaskForWork.Integral += integral;
if (TaskForWork.LimitIntegral <= TaskForWork.Integral)
{
this.Complete();
}
else
{
var index = examList.List.IndexOf(exam);
if (index == examList.Count - 1)
{
DoWork();
}
else
{
index++;
DoExam(course, examList.List[index], examList);
}
}
}
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
public override bool Start(F****r f****r)
{
if (!base.Start(f****r))
{
return(false);
}
Start();
return(true);
}
public virtual bool Start(F****r f****r)
{
this.F****r = f****r;
if (TaskStatus != TaskStatus.Initial)
{
return(false);
}
TaskStatus = TaskStatus.Working;
return(true);
}
private async System.Threading.Tasks.Task GetArenaBothSide()
{
if (await F****r.GetArenaBothSide(Arena))
{
await F****r.ReadyToFight();
return;
}
else
{
await GetArenaBothSide();
}
}
public async override void DoWork()
{
try
{
List <ExerciseAnswer> answers;
foreach (var item in breakthroughList.List)
{
answers = new List <ExerciseAnswer>();
if (!item.IsPass)
{
await F****r.StartBreakthrough(item);
foreach (var question in item.Questions)
{
answers.Add(new ExerciseAnswer()
{
TmID = question.TmID, AnswerContent = question.Answers.Replace(";", ",")
});
}
await F****r.HandIn(item, answers, 15);
await F****r.GetResult(item.Result);
TaskForWork.Integral += item.Result.Integral;
if (TaskForWork.LimitIntegral <= TaskForWork.Integral)
{
this.Complete();
return;
}
}
}
if (TaskForWork.LimitIntegral > TaskForWork.Integral)
{
Start();
}
}
catch (TransportException ex)
{
F****r.Worker.ReportError(ex.Message);
F****r.Worker.Say("闯关答题答题失败!");
Stop();
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
F****r.Worker.Say("闯关答题答题失败!");
Stop();
}
}
public void Start(F****r f****r)
{
this.f****r = f****r;
this.Complete = false;
if (timer == null)
{
timer = new Timer(F****r.POLLING_TIME);
timer.Elapsed += Timer_Elapsed;
}
if (timer.Enabled)
{
timer.Stop();
}
timer.Start();
}
public override bool Start(F****r f****r)
{
if (!base.Start(f****r))
{
f****r.Worker.Say("每周一练启动失败!");
return(false);
}
if (TaskForWork.LimitIntegral <= TaskForWork.Integral)
{
Complete();
return(true);
}
Start();
return(true);
}
public async override void DoWork()
{
try
{
List <ExerciseAnswer> answers = new List <ExerciseAnswer>();
var practiceQuestionList = await F****r.StartWeeklyPractice();
foreach (var question in practiceQuestionList.Questions)
{
answers.Add(new ExerciseAnswer()
{
TmID = question.TmID, AnswerContent = question.Answers.Replace(";", ",")
});
}
await F****r.HandIn(practiceQuestionList, answers, 15);
await F****r.GetResult(practiceQuestionList.Result);
TaskForWork.Integral += practiceQuestionList.Result.Integral;
if (TaskForWork.LimitIntegral <= TaskForWork.Integral)
{
this.Complete();
return;
}
else
{
Start();
}
}
catch (TransportException ex)
{
F****r.Worker.ReportError(ex.Message);
F****r.Worker.Say("每日一练答题失败!");
Stop();
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
F****r.Worker.Say("每日一练答题失败!");
Stop();
}
}
private async void Start()
{
try
{
breakthroughList = await F****r.GetBreakthroughList();
DoWork();
}
catch (TransportException ex)
{
F****r.Worker.ReportError(ex.Message);
F****r.Worker.Say("闯关答题启动失败!");
Stop();
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
F****r.Worker.Say("闯关答题启动失败!");
Stop();
}
}
private async System.Threading.Tasks.Task UpdateQuestionBank(Result result)
{
try
{
DataContext dataContext = new DataContext();
if (await F****r.ReviewPaper(result, Exam))
{
foreach (var item in result.Questions)
{
if (await dataContext.GetRow(item.TmID) == null)
{
await dataContext.InsertRow(item);
}
}
}
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
private async void StartRound(int roundIndex)
{
try
{
var round = await F****r.Fight(Arena);
if (round == null)
{
throw new Exception("error");
}
if (round.CurrentIndex == roundIndex && round.Status == "Start")
{
if (Arena.Rounds == null)
{
Arena.Rounds = new List <Round>();
}
Arena.Rounds.Add(round);
Timer timer = new Timer();
timer.Interval = new Random().Next(5000, 9000);
timer.AutoReset = false;
timer.Elapsed += new ElapsedEventHandler((s, e) => OnReply(s, e, roundIndex));
timer.Start();
}
else if (roundIndex == Arena.TmNumber)
{
if (round.CurrentIndex == 0)
{
await F****r.EndFight();
if (await F****r.GetPKResult(Arena))
{
var gladiator = Arena.Results.FindIndex(s => s.Gladiator.UserName == F****r.Worker.User.UserName);
if (gladiator < 0)
{
throw new Exception("error");
}
TaskForWork.Integral += Arena.Results[gladiator].PKScroe;
if (TaskForWork.LimitIntegral == TaskForWork.Integral)
{
Complete();
}
else
{
DoWork();
}
}
}
else
{
StartRound(roundIndex);
}
}
else
{
StartRound(roundIndex);
}
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
}
}
public async Task <decimal> StartExam(Exam exam)
{
try
{
DataContext dataContext = new DataContext();
List <Answer> answers = new List <Answer>();
while (true)
{
if (!await F****r.StartExam(exam))
{
return(0);
}
if (exam.Papers == null || exam.Papers.Count == 0)
{
return(0);
}
var paper = exam.Papers[exam.Papers.Count - 1];
answers.Clear();
foreach (var item in paper.Questions)
{
var question = await dataContext.GetRow(item.TmID);
Answer answer = new Answer();
answer.TmID = item.TmID;
answers.Add(answer);
if (question == null)
{
answer.AnswerContent = "";
}
else
{
answer.AnswerContent = question.Answers.Replace(";", ",");
}
}
if (!await F****r.HandIn(paper, exam, answers))
{
continue;
}
await F****r.GetResult(paper.Result);
if (paper.Result.ErrorQuestionCount != 0) //答题失败
{
await UpdateQuestionBank(paper.Result);
continue;
}
else
{
return(paper.Result.Integral);
}
}
}
catch (Exception ex)
{
F****r.Worker.ReportError(ex.Message);
Stop();
return(0);
}
}
