public Confidence Evaluate(AdvancedRobot robot, ScannedRobotEvent e, BattleEvents battleEvents)
{
Confidence confidence = Confidence.DonotBlameMeIfILoose;
if (e.Distance >= 200)
{
if (robot.Energy < e.Energy)
{
confidence = Confidence.DesignedForThis;
}
else
{
confidence = Confidence.CanHandleIt;
}
}
else
{
if (robot.Energy < e.Energy)
{
confidence = Confidence.TryMe;
}
else
{
confidence = Confidence.DonotBlameMeIfILoose;
}
}
return(confidence);
}
private static void AddSomeBattles()
{
var Darkwarevents = new List <BattleEvents>();
var BattleofMongolia = new BattleEvents {
Description = "The final battle for the Mongolian Empire"
};
Darkwarevents.Add(BattleofMongolia);
var DarkwarLog = new BattleLog {
Name = "Dark War Battlelog", BattleEvents = Darkwarevents
};
DateTime darkwartimestart = DateTime.Parse("1573/10/12");
DateTime darkwartimesend = DateTime.Parse("1575/03/19");
var Darkwar = new Battle {
Name = "The Dark War", Description = "The bloodiest war in histoy", Brutal = true, Startdate = darkwartimestart, Enddate = darkwartimesend, BattleLog = DarkwarLog
};
using (var context = new SamuraiContext())
{
context.Battles.Add(Darkwar);
context.SaveChanges();
}
}
/*
* In this robot, as in many others, onScannedRobot is used as the main place to put actions done every tick.
*/
public Operations HandleScanedRobot(AdvancedRobot robot, ScannedRobotEvent e, ScannedRobotEvent previousScaned,
Operations operations, BattleEvents battleEvents)
{
var newOperations = operations.Clone();
SetFirePowerBasedOnEnergy(robot, e, battleEvents);
double absBearing = e.BearingRadians + robot.HeadingRadians;
/*
* ==================Movement Section============================
* This makes us put a log into our log when we notice the enemy firing.
* To see the actual logging of the wave, look at the logWave method.
*/
double energyChange = (enemyEnergy - (enemyEnergy = e.Energy));
MovementWave w;
if (energyChange <= 3 && energyChange >= 0.1)
{
logMovementWave(e, energyChange, robot);
}
/*
* After we are done checking to see if we need to log any waves, we'll decide where to move.
* To see this process take a peek at the chooseDirection method.
*/
chooseDirection(project(new PointF((float)robot.X, (float)robot.Y), e.Distance, absBearing), newOperations, robot);
/*
* logs a gun wave when we fire;
*/
if (robot.GunHeat == 0)
{
logFiringWave(e, robot);
}
/*
* This method checks our waves to see if they have reached the enemy yet.
*/
checkFiringWaves(project(new PointF((float)robot.X, (float)robot.Y), e.Distance, absBearing), robot);
/*
* Aiming our gun and firing
*/
newOperations.TurnGunRightRadians = Utils.NormalRelativeAngle(absBearing - robot.GunHeadingRadians)
+ gunAngles[8 + (int)(e.Velocity * Math.Sin(e.HeadingRadians - absBearing))];
if (robot.Energy >= 5)
{
newOperations.BulletPower = FIRE_POWER;
}
else //don't fire gun if we are about to die, hoping that enemy will reach to diable first
{
newOperations.BulletPower = null;
}
newOperations.TurnRadarRightRadians = Utils.NormalRelativeAngle(absBearing - robot.RadarHeadingRadians) * 2;
return(newOperations);
}
public Operations HandleScanedRobot(AdvancedRobot robot, ScannedRobotEvent e, ScannedRobotEvent previousScaned,
Operations operations, BattleEvents battleEvents)
{
var calculatedParams = new CalculatedParams(robot, e);
var newOperations = operations.Clone();
doMoebius(0, patternMatcher.Length, e, SEARCH_DEPTH, calculatedParams.AbsoluteBearing, newOperations, robot);
newOperations.TurnRadarRightRadians = Utils.NormalRelativeAngle(calculatedParams.AbsoluteBearing - robot.RadarHeadingRadians) * 2;
return(newOperations);
}
public BaseGameEvents()
{
Player = new PlayerEvents();
Time = new TimeEvents();
Monsters = new MonsterEvents();
Entities = new EntityEvents();
Flow = new FlowEvents();
Health = new HPEvents();
Battle = new BattleEvents();
Traps = new TrapEvents();
Blocks = new BlockingEvents();
}
public void Connect(params Battle[] battles)
{
if (battles != null)
{
foreach (var battle in battles)
{
if (battle != null)
{
BattleEvents.Add(new BattleEvent()
{
Battle = battle
});
}
}
}
}
private static void AddOneSamuraiWithRelatedData()
{
var BattleofChinaevents = new List <BattleEvents>();
var BattleofChina = new BattleEvents {
Description = "The battle of China"
};
BattleofChinaevents.Add(BattleofChina);
var BattleofChinaLog = new BattleLog
{
Name = "Battle of China Logs",
BattleEvents = BattleofChinaevents,
};
// var Djingisquotelist = new List<Quotestext>();
// Djingisquotelist.Add(Lame);
// Djingisquotelist.Add(Awesome);
var Djingis = new Samurai {
Name = "Djingis khan", Age = 60, Haircut = Haircut.Oicho
};
var b1 = new Battle
{
Name = "Battle of China",
BattleLog = BattleofChinaLog,
Startdate = DateTime.Parse("1553/12/10"),
Enddate = DateTime.Parse("1559/05/25"),
SamuraiBattles = new List <SamuraiBattle>
{
new SamuraiBattle {
Samurai = Djingis
},
}
};
using (var context = new SamuraiContext())
{
context.Battles.Add(b1);
context.Samurais.Add(Djingis);
context.SaveChanges();
}
}
public Confidence Evaluate(AdvancedRobot robot, ScannedRobotEvent e, BattleEvents battleEvents)
{
Confidence confidence = Confidence.DonotBlameMeIfILoose;
return(confidence);
}
Confidence IHandleScanedRobot.Evaluate(AdvancedRobot robot, ScannedRobotEvent e, BattleEvents battleEvents)
{
throw new NotImplementedException();
}
Operations IHandleScanedRobot.HandleScanedRobot(AdvancedRobot robot, ScannedRobotEvent e, ScannedRobotEvent previousScaned, Operations operations, BattleEvents battleEvents)
{
throw new NotImplementedException();
}
private static void SetFirePowerBasedOnEnergy(AdvancedRobot robot, ScannedRobotEvent e, BattleEvents battleEvents)
{
if (robot.Energy > 70)
{
FIRE_POWER = 3;
}
else if (robot.Energy <= 70 && robot.Energy > 50)
{
FIRE_POWER = 1;
}
else if (robot.Energy <= 50 && robot.Energy >= 30 || e.Energy < 15)
{
FIRE_POWER = 0.5;
}
else
{
FIRE_POWER = 0.1;
}
}
public Operations HandleScanedRobot(AdvancedRobot robot, ScannedRobotEvent e, ScannedRobotEvent previousScaned,
Operations operations, BattleEvents battleEvents)
{
var newOperations = operations.Clone();
double absoluteBearing = robot.HeadingRadians + e.BearingRadians;
PointF myLocation = new PointF((float)robot.X, (float)robot.Y);
PointF predictedLocation = projectMotion(myLocation, absoluteBearing, e.Distance);
double predictedHeading;
double enemyTurnRate = -Utils.NormalRelativeAngle(expectedHeading - (predictedHeading = expectedHeading = e.HeadingRadians));
double bulletPower = Math.Min(e.Distance < 250 ? 500 / e.Distance : 200 / e.Distance, 3);
int time = 0;
while ((time++) * (20 - (3 * bulletPower)) < myLocation.Distance(predictedLocation) - 18)
{
predictedHeading += (enemyTurnRate / 3);
predictedLocation = projectMotion(predictedLocation, predictedHeading, e.Velocity);
if (!new RectangleF(18, 18, 764, 564).Contains(predictedLocation))
{
break;
}
}
double maxValue = Double.MinValue;
double angle = 0;
do
{
double value = Math.Abs(Math.Cos(Utils.NormalRelativeAngle(absoluteBearing - angle))) * e.Distance / 150;
PointF testedLocation = projectMotion(myLocation, angle, 8);
value -= testedLocation.Distance(predictedLocation);
value -= testedLocation.Distance(new PointF(400, 300)) / 3;
if (!new RectangleF(30, 30, 740, 540).Contains(testedLocation))
{
value -= 10000;
}
if (value > maxValue)
{
maxValue = value;
double turnAngle = angle - robot.HeadingRadians;
if (headingEnemy)
{
newOperations.Ahead = (Math.Cos(turnAngle) > 0 ? 100 : -100);
newOperations.TurnRightRadians = (Math.Tan(turnAngle));
}
else
{
var absoluteBearingMedkit = lastMedicalKitEvent.BearingRadians + robot.HeadingRadians;
double turn = absoluteBearingMedkit + Math.PI / 2;
turn -= Math.Max(0.5, (1 / lastMedicalKitEvent.Distance) * 100) * newOperations.Direction;
newOperations.TurnRightRadians = Utils.NormalRelativeAngle(turn - robot.HeadingRadians);
newOperations.Ahead = (Math.Cos(turn) > 0 ? 100 : -100);
}
}
} while ((angle += 0.01) < Math.PI * 2);
robot.MaxVelocity = (Math.Abs(robot.TurnRemaining) < 30 ? 8 : 8 - Math.Abs(robot.TurnRemaining / 30));
double gunTurn = Utils.NormalRelativeAngle(Math.Atan2(predictedLocation.X - myLocation.X, predictedLocation.Y - myLocation.Y) - robot.GunHeadingRadians);
newOperations.TurnGunRightRadians = (gunTurn);
if ((Math.Abs(gunTurn) < Math.PI / 9) && (robot.GunHeat == 0.0))
{
newOperations.BulletPower = (bulletPower);
}
newOperations.TurnRadarRightRadians = (2 * Utils.NormalRelativeAngle(absoluteBearing - robot.RadarHeadingRadians));
return(newOperations);
}
public Operations HandleScanedRobot(AdvancedRobot robot, ScannedRobotEvent e, ScannedRobotEvent previousScaned, Operations operations, BattleEvents battleEvents)
{
var calculatedParams = new CalculatedParams(robot, e);
var newOperations = operations.Clone();
if (previousScaned != null && previousScaned.Energy > e.Energy)
{
OnEnemyFired(e, newOperations);
}
double turn = calculatedParams.AbsoluteBearing + Math.PI / 2;
turn -= Math.Max(0.5, (1 / e.Distance) * 100) * newOperations.Direction;
newOperations.TurnRightRadians = Utils.NormalRelativeAngle(turn - robot.HeadingRadians);
//This line makes us slow down when we need to turn sharply.
newOperations.MaxVelocity = 400 / robot.TurnRemaining;
newOperations.Ahead = 100 * newOperations.Direction;
if (newOperations.BulletPower.HasValue)
{
newOperations.TurnGunRightRadians =
Utils.NormalRelativeAngle(
GetCircularTargeting(robot, e, previousScaned != null ? previousScaned.HeadingRadians : 0,
newOperations.BulletPower.Value, calculatedParams) - robot.GunHeadingRadians);
}
newOperations.TurnRadarRightRadians = Utils.NormalRelativeAngle(calculatedParams.AbsoluteBearing - robot.RadarHeadingRadians) * 2;
return(newOperations);
}
