public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
General general = model.FindGeneralByTeam(team);
double angle = -10;
if (gameEvent.isButtonPressed(upButton) && gameEvent.isButtonPressed(rightButton))
{
angle = -Math.PI / 4;
}
else if (gameEvent.isButtonPressed(downButton) && gameEvent.isButtonPressed(rightButton))
{
angle = Math.PI / 4;
}
else if (gameEvent.isButtonPressed(downButton) && gameEvent.isButtonPressed(leftButton))
{
angle = 3 * Math.PI / 4;
}
else if (gameEvent.isButtonPressed(leftButton) && gameEvent.isButtonPressed(upButton))
{
angle = -(3 * Math.PI / 4);
}
else if (gameEvent.isButtonPressed(upButton))
{
angle = -Math.PI / 2;
}
else if (gameEvent.isButtonPressed(rightButton))
{
angle = 0;
}
else if (gameEvent.isButtonPressed(downButton))
{
angle = Math.PI / 2;
}
else if (gameEvent.isButtonPressed(leftButton))
{
angle = -Math.PI;
}
if (angle != -10)
{
Vector newVelocity = new Vector(Math.Cos(angle) * gameEvent.model.speedConstant,
Math.Sin(angle) * gameEvent.model.speedConstant);
general.Velocity = Vector.Add(Vector.Multiply(0.75, general.Velocity),
Vector.Multiply(0.25, newVelocity));
general.PrevSpeed = general.Velocity;
}
else
{
general.Velocity = new Vector(0, 0);
}
general.Position = new Vector(general.Position.X + (general.Velocity.X * gameEvent.deltaTime),
general.Position.Y + (general.Velocity.Y * gameEvent.deltaTime));
}
public void recruiteDrones(GameEvent gameEvent, QuantumModel model, General general, double cloudRadius)
{
double milsForDrone = model.milsPerDronToRecruite;
int amountOfDroneToRecruite = (int)((recruiteAccumulatedTime + gameEvent.deltaTime) / milsForDrone);
recruiteAccumulatedTime += gameEvent.deltaTime - amountOfDroneToRecruite * milsForDrone;
if (amountOfDroneToRecruite <= 0)
{
return;
}
Outpost outpost = model.findOutpostByPosition(general.Position, 1.5 * model.cloudRadius);
if (outpost == null)
{
return;
}
while (amountOfDroneToRecruite > 0)
{
Drone drone = findDrone(outpost, general, cloudRadius);
if (drone == null)
{
return;
}
drone.Order = DroneOrder.MoveToGeneral;
amountOfDroneToRecruite--;
}
}
public void cacheModel(QuantumModel model)
{
foreach (General general in model.Generals)
{
cacheDrones(general);
}
}
public static MessageEnvelope ToMessageEnvelope(this QuantumModel quantum)
{
if (quantum == null)
{
throw new ArgumentNullException(nameof(quantum));
}
return(XdrConverter.Deserialize <MessageEnvelope>(quantum.RawQuantum));
}
public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
GeneralsDronesCache dronesCached = gameEvent.game.largeCache;
double maxFightDistance = 150;
foreach (General general in model.Generals)
{
List <Team> enemyTeams = new List <Team>();
int beamSizeLimit = 1000;
foreach (General enemyGeneral in model.Generals)
{
if (general.Team == enemyGeneral.Team)
{
continue;
}
enemyTeams.Add(enemyGeneral.Team);
}
foreach (Drone drone in general.Drones)
{
Vector fightDistanceCorner = new Vector(maxFightDistance, maxFightDistance);
dronesCached.findDrones(enemyTeams, Vector.Subtract(drone.Position, fightDistanceCorner),
Vector.Add(drone.Position, fightDistanceCorner),
droneList => {
foreach (Drone enemyDrone in droneList)
{
if (Vector.Subtract(enemyDrone.Position, drone.Position).Length > maxFightDistance)
{
continue;
}
enemyDrone.Health--;
if (beamSizeLimit-- > 0)
{
model.Beams.Add(new Beam(drone.Position, enemyDrone.Position, general.Team));
}
break;
}
});
}
}
foreach (General general in gameEvent.model.Generals)
{
general.Drones.RemoveAll(p => p.Health <= 0);
}
}
private void CreateClientGame(QuantumModel model, int width, int height, OnAsynCreate callback)
{
QuantumGame game = new QuantumGame();
game.gameNetwork = network;
game.AddController(new NetworkSync(false));
game.start(model, width, height);
callback(game);
}
public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
foreach (General general in model.Generals)
{
foreach (Drone drone in general.Drones)
{
moveDrone(gameEvent, general, drone);
}
}
}
private Vector getCloudCenterPosition(QuantumModel model, General general, Drone drone)
{
if (drone.Order == DroneOrder.MoveToGeneral)
{
return(general.Position);
}
else if (drone.Order == DroneOrder.MoveToOutpost)
{
return(model.findOutpostById(drone.TargetOutpost).Position);
}
else if (drone.Order == DroneOrder.MoveToPosition)
{
return(drone.TargetPosition);
}
throw new Exception("Unable to found cloud center position");
}
public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
usedTime += gameEvent.deltaTime;
if (usedTime < model.outpostConquestTime)
{
return;
}
usedTime -= model.outpostConquestTime;
foreach (Outpost outpost in gameEvent.model.Outposts)
{
HashSet <General> generalsDroneParticipators = new HashSet <General>();
foreach (General general in model.Generals)
{
if (general.FindDroneCloseToOutpost(outpost, model.cloudRadius) != null)
{
generalsDroneParticipators.Add(general);
}
}
if (generalsDroneParticipators.Count == 1)
{
outpost.Team = generalsDroneParticipators.First().Team;
continue;
}
HashSet <General> generalsParticipators = new HashSet <General>();
foreach (General general in model.Generals)
{
if (Vector.Subtract(general.Position, outpost.Position).Length < model.cloudRadius)
{
generalsParticipators.Add(general);
}
}
if (generalsParticipators.Count == 1)
{
outpost.Team = generalsParticipators.First().Team;
}
}
}
public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
double cloudRadius = model.cloudRadius;
General general = model.FindGeneralByTeam(team);
Vector targetPosition = gameEvent.mousePosition;
if (gameEvent.isButtonPressed(orderButton))
{
giveOrderToDrones(gameEvent, model, general, targetPosition, cloudRadius);
}
if (gameEvent.isButtonPressed(recruiteKey))
{
recruiteDrones(gameEvent, model, general, cloudRadius);
}
}
public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
foreach (Outpost outpost in model.Outposts)
{
if (outpost.Team == Team.neutral)
{
continue;
}
int newDronesToRespawn = (int)((gameEvent.deltaTime + outpost.respawnTimerAccumulator) / model.milsPerDronRespawn);
outpost.respawnTimerAccumulator += gameEvent.deltaTime - newDronesToRespawn * model.milsPerDronRespawn;
if (newDronesToRespawn == 0)
{
continue;
}
General general = model.FindGeneralByTeam(outpost.Team);
int currrentAmountDronesOnOutpost = countDronesOnOutpost(outpost, general, model.cloudRadius);
if (currrentAmountDronesOnOutpost > model.maxRespawnAmount)
{
continue;
}
int amountToRespawn = Math.Min(model.maxRespawnAmount - currrentAmountDronesOnOutpost, newDronesToRespawn);
for (int i = 0; i < amountToRespawn; i++)
{
Drone drone = new Drone();
drone.Order = DroneOrder.MoveToOutpost;
drone.TargetOutpost = outpost.id;
drone.Position = new Vector(outpost.Position.X + random.NextDouble(), outpost.Position.Y + random.NextDouble());
//drone.Position = new Vector(outpost.Position.X, outpost.Position.Y);
general.AddDrone(drone);
}
}
}
private void CreateServerGame(int width, int height, OnAsynCreate callback)
{
currentTeam = (random.Next() % 2 == 0) ? Team.blue : Team.green;
QuantumMapBuilder mapBuilder = new QuantumMapBuilder();
model = mapBuilder.initializeMap(width, height);
ShareGameEvent shareGame = new ShareGameEvent();
shareGame.model = model;
network.BroadcastMessage(shareGame);
QuantumGame game = new QuantumGame();
game.gameNetwork = network;
game.AddController(new NetworkSync(true));
game.start(model, width, height);
callback(game);
}
public static QuantumContainer ToQuantumContainer(this QuantumModel quantum, AccountStorage accountStorage = null)
{
if (quantum == null)
{
throw new ArgumentNullException(nameof(quantum));
}
var quantumContainer = XdrConverter.Deserialize <QuantumContainer>(quantum.Bin);
if (accountStorage != null)
{
foreach (var effect in quantumContainer.Effects)
{
if (effect.Account == 0)
{
continue;
}
effect.AccountWrapper = accountStorage.GetAccount(effect.Account);
}
}
return(quantumContainer);
}
public void execute(GameEvent gameEvent)
{
QuantumModel model = gameEvent.model;
HashSet <Team> outpostHolders = new HashSet <Team>();
foreach (Outpost outpost in model.Outposts)
{
outpostHolders.Add(outpost.Team);
}
foreach (General general in model.Generals)
{
if (general.Drones.Count > 0)
{
outpostHolders.Add(general.Team);
}
}
if (outpostHolders.Count == 1 && outpostHolders.First() != Team.neutral)
{
model.Winner = outpostHolders.First();
}
}
public void giveOrderToDrones(GameEvent gameEvent, QuantumModel model, General general, Vector targetPosition, double cloudRadius)
{
Vector distanceToPoint = Vector.Subtract(targetPosition, general.Position);
double milsForDrone = distanceToPoint.Length * distanceToPoint.Length * distanceToPoint.Length / model.milsOrderFactor;
int amountOfDroneToSend = (int)((orderAccumulatedTime + gameEvent.deltaTime) / milsForDrone);
orderAccumulatedTime += gameEvent.deltaTime - amountOfDroneToSend * milsForDrone;
Outpost outpost = model.findOutpostByPosition(targetPosition, model.cloudRadius);
foreach (Drone dron in general.Drones)
{
if (amountOfDroneToSend <= 0)
{
break;
}
if (dron.Order == DroneOrder.MoveToGeneral &&
Vector.Subtract(dron.Position, general.Position).Length < cloudRadius * 1.5)
{
amountOfDroneToSend--;
if (outpost != null)
{
dron.TargetOutpost = outpost.id;
dron.Order = DroneOrder.MoveToOutpost;
}
else
{
dron.TargetPosition = targetPosition;
dron.Order = DroneOrder.MoveToPosition;
}
}
}
}
private void moveDrone(GameEvent gameEvent, General general, Drone drone)
{
Vector targetPosition = getCloudCenterPosition(gameEvent.model, general, drone);
QuantumModel model = gameEvent.model;
double cloudRadius = model.cloudRadius;
Vector distanceToCenter = Vector.Subtract(targetPosition, drone.Position);
Vector directionToCenter = distanceToCenter;
double positionChange = model.dronSpeedConstant * gameEvent.deltaTime;
if (directionToCenter.Length == 0)
{
drone.Position += new Vector(random.NextDouble(), random.NextDouble());
return;
}
directionToCenter.Normalize();
Vector droneMovement = Vector.Multiply(positionChange, directionToCenter);
double precision = 0.9;
double randomValue = random.NextDouble() * precision * 2 + 1 - precision;
double minDistanceForAction;
if (drone.Order == DroneOrder.MoveToGeneral ||
drone.Order == DroneOrder.MoveToOutpost)
{
minDistanceForAction = model.cloudRadius;
}
else if (drone.Order == DroneOrder.MoveToPosition)
{
minDistanceForAction = model.moveToPositionRadius;
}
else
{
minDistanceForAction = 1;
}
if (distanceToCenter.Length > minDistanceForAction + positionChange)
{
drone.Position = Vector.Add(drone.Position, Vector.Multiply(droneMovement, randomValue));
}
else if (drone.Order == DroneOrder.MoveToGeneral ||
drone.Order == DroneOrder.MoveToOutpost)
{
if (general.Team == Team.green)
{
drone.Position = Vector.Add(drone.Position, new Vector(randomValue * droneMovement.Y, -randomValue * droneMovement.X));
}
else
{
drone.Position = Vector.Add(drone.Position, new Vector(randomValue * -droneMovement.Y, randomValue * droneMovement.X));
}
}
else if (drone.Order == DroneOrder.MoveToPosition)
{
drone.Order = DroneOrder.MoveToGeneral;
}
}
public void Complete(QuantumModel quantum)
{
Quantum = quantum ?? throw new ArgumentNullException(nameof(quantum));
}
