protected override void Execute()
{
Debug.Log("Execute pregnancy");
if (setPregnant)
{
parent.isPregnant = true;
if (parent.childPart == null)
{
var commandEvent = new CommandEvent(new BirthCommand(parent, position), 1);
EgoEvents <CommandEvent> .AddEvent(commandEvent);
var commandEvent2 = new CommandEvent(new PregnancyCommand(parent, position, false), 1);
EgoEvents <CommandEvent> .AddEvent(commandEvent2);
}
else
{
if (!parent.childPart.isPregnant)
{
var commandEvent = new CommandEvent(new PregnancyCommand(parent.childPart, position, true), 1);
EgoEvents <CommandEvent> .AddEvent(commandEvent);
var commandEvent2 = new CommandEvent(new PregnancyCommand(parent, position, false), 1);
EgoEvents <CommandEvent> .AddEvent(commandEvent2);
}
}
}
else
{
parent.isPregnant = false;
}
}
public override void Update()
{
constraint.ForEachGameObject(
(ego, player) =>
{
float moveVertical = Input.GetAxis("Vertical");
if (gameIsOver)
{
// do nothing is game is over
}
else
{
if (Input.GetKey(KeyCode.UpArrow))
{
Vector3 now = player.transform.position;
player.transform.position = new Vector3(now.x, now.y + player.speed, now.z);
//
// invoke an event to check if the player car has crossed the line
//
if (ego.gameObject.name == "Player")
{
var eve = new CheckEndOfLineEvent(ego);
EgoEvents <CheckEndOfLineEvent> .AddEvent(eve);
}
}
}
}
);
}
void Handle(InputDataReceivedEvent e)
{
constraint.ForEachGameObject((ego, ready) => {
if (e.data == 5 && e.playerID == 1)
{
ready.playerOneReady = true;
EgoEvents <PlayerReadyEvent> .AddEvent(new PlayerReadyEvent(1));
}
if (e.data == 6 && e.playerID == 1)
{
ready.playerOneReady = false;
EgoEvents <PlayerNotReadyEvent> .AddEvent(new PlayerNotReadyEvent(1));
}
if (e.data == 5 && e.playerID == 2)
{
ready.playerTwoReady = true;
EgoEvents <PlayerReadyEvent> .AddEvent(new PlayerReadyEvent(2));
}
if (e.data == 6 && e.playerID == 2)
{
ready.playerOneReady = false;
EgoEvents <PlayerNotReadyEvent> .AddEvent(new PlayerNotReadyEvent(2));
}
});
}
protected override void Execute()
{
parent.isPregnant = false;
if (parent.childPart == null)
{
child = Ego.AddGameObject(Object.Instantiate <GameObject>(parent.snakePrefab)).GetComponent <SnakePartComponent>();
child.snakePrefab = parent.snakePrefab;
child.transform.position = position;
child.transform.rotation = parent.transform.rotation;
child.transform.parent = parent.container;
child.container = parent.container;
parent.childPart = child;
//child.parentPart = parent;
createdNew = true;
}
else
{
createdNew = false;
if (!parent.childPart.isPregnant)
{
parent.childPart.isPregnant = true;
var commandEvent = new CommandEvent(new PregnancyCommand(parent.childPart, position, true), 1);
EgoEvents <CommandEvent> .AddEvent(commandEvent);
}
}
}
void OnTriggerExit2D(Collider2D collider2d)
{
var e = new TriggerExit2DEvent(egoComponent, collider2d.gameObject.GetComponent <EgoComponent>(),
collider2d);
EgoEvents <TriggerExit2DEvent> .AddEvent(e);
}
private void Handle(CheckEndOfLineEvent e)
{
//
// Check to see if Ego entity "car" or "opps_x" has crossed the finish line
//
constraint.ForEachGameObject(
(egoComp, endofline) =>
{
//
// If any car crosses the finish line, then game ends
//
if (e.car.transform.position.y > endofline.transform.position.y)
{
//
// Following is a play line to see how to add a component to an entity
// Issue the pause component to the car the just crossed the finish line
//
Ego.AddComponent <PauseComponent>(egoComp);
//
// Invoke the event that causes the EndOfGameSystem to turn on "Game Over" text
//
EgoEvents <EndOfGameEvent> .AddEvent(new EndOfGameEvent(true));
}
}
);
}
void OnCollisionStay2D(Collision2D collision)
{
var e = new CollisionStay2DEvent(egoComponent, collision.gameObject.GetComponent <EgoComponent>(),
collision);
EgoEvents <CollisionStay2DEvent> .AddEvent(e);
}
public override void Update()
{
//HasSpeedUpComponent speedUp;
constraint.ForEachGameObject((egoComponent, transform, powerUpComponent, movementComponent) => {
if (powerUpComponent.powerUpActivated)
{
movementComponent.flySpeed = 4;
movementComponent.curvspeed = 2.9f;
Ego.DestroyComponent <HasSpeedUpComponent>(egoComponent);
}
if (powerUpComponent.powerUpActivated)
{
powerUpComponent.playerPowerUpTimer += Time.deltaTime;
}
if (powerUpComponent.playerPowerUpTimer >= 2)
{
powerUpComponent.playerPowerUpTimer = -1f;
movementComponent.flySpeed = 2;
movementComponent.curvspeed = 2;
powerUpComponent.powerUpActivated = false;
}
HasSpeedUpComponent speed;
if ((KutiInput.Instance.GetButtonDown(powerUpComponent.powerUpButton) || Input.GetKey(powerUpComponent.powerUpButtonPC) && egoComponent.TryGetComponents(out speed)))
{
var ev = new OnActivatePowerUp(powerUpComponent.playerID, egoComponent);
EgoEvents <OnActivatePowerUp> .AddEvent(ev);
}
});
}
public static EgoComponent GenerateGun()
{
EntityBuilder entity = EntityBuilder.Generate().WithPhysics(typeof(BoxCollider2D), .5f).WithGraphics("Images/gun");
Interactive c = Ego.AddComponent <Interactive>(entity);
c.InteractAction = e => EgoEvents <AttachEvent> .AddEvent(new AttachEvent(c.GetComponent <EgoComponent>(), e));
Ego.AddComponent <Mountpoint>(entity);
Useable u = Ego.AddComponent <Useable>(entity);
u.UseAction = e => {
Transform transform = u.transform;
double theta = transform.rotation.eulerAngles.z * Mathf.Deg2Rad;
Vector2 force = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta));
force.Normalize();
// generate new projectile, add motion in direction at speed
EgoComponent bullet = Ego.AddGameObject(GenerateBullet().gameObject);
bullet.transform.rotation = transform.rotation;
bullet.transform.position = transform.position;
bullet.gameObject.SetActive(true);
EgoEvents <SetVelocityByEvent> .AddEvent(new SetVelocityByEvent(bullet, force));
};
return(entity);
}
public static void SetParent(EgoComponent parent, EgoComponent child)
{
if (child == null)
{
Debug.LogWarning("Cannot set the Parent of a null Child");
}
EgoEvents <SetParent> .AddEvent(new SetParent( parent, child ));
}
public static EgoComponent AddGameObject(GameObject gameObject)
{
var egoComponent = AddGameObjectToChildren(gameObject.transform);
EgoEvents <AddedGameObject> .AddEvent(new AddedGameObject( gameObject, egoComponent ));
return(egoComponent);
}
void TryDash(Movement movement, ActorComponent actor)
{
movement.velocity.x = (-movement.velocity.x) + Mathf.Sign(movement.velocity.x) * 30f;
movement.velocity.y -= movement.velocity.y;
var e = new DashEvent(actor.guid, movement.velocity);
EgoEvents <DashEvent> .AddEvent(e);
}
public static void Destroy(GameObject gameObject)
{
var egoComponent = gameObject.GetComponent <EgoComponent>();
EgoEvents <DestroyedGameObject> .AddEvent(new DestroyedGameObject( gameObject, egoComponent ));
EgoCleanUp.Destroy(gameObject);
}
public static void DestroyGameObject(EgoComponent egoComponent)
{
var gameObject = egoComponent.gameObject;
EgoEvents <DestroyedGameObject> .AddEvent(new DestroyedGameObject( gameObject, egoComponent ));
EgoCleanUp.Destroy(egoComponent.gameObject);
}
void SetOffGround(BottomComponent bottom)
{
if (bottom.touchingGround)
{
var e = new TouchGroundEvent(bottom.actor.guid, false);
EgoEvents <TouchGroundEvent> .AddEvent(e);
}
bottom.touchingGround = false;
}
void Handle(JumpEvent e)
{
constraint.ForEachGameObject((egoComponent, transform, movement) =>
{
MovementComponent.ViewDirection moveDirectionVar;
moveDirectionVar = movement.viewDirection;
EgoEvents <JumpEvent> .AddEvent(new JumpEvent(moveDirectionVar.ToString()));
});
}
void SetOnGround(BottomComponent bottom)
{
if (!bottom.touchingGround)
{
var e = new TouchGroundEvent(bottom.actor.guid, true);
EgoEvents <TouchGroundEvent> .AddEvent(e);
}
bottom.touchingGround = true;
}
public override void Update()
{
constraint.ForEachGameObject((ego, ready) => {
if (ready.playerOneReady && ready.playerTwoReady)
{
var e = new SwitchSceneEvent();
EgoEvents <SwitchSceneEvent> .AddEvent(e);
}
});
}
public override void FixedUpdate()
{
//CHeck for overlapping points with SpceTrail
constraint.ForEachGameObject((egoComponent, spriteRenderer, collisionComponent, lineRenderer, movement, player) => {
if (movement.myFlyStatus == MovementComponent.FlyStatus.flying)
{
constraint.ForEachGameObject((egoComponent2, spriteRenderer2, collisionComponent2, lineRenderer2, movement2, player2) => {
if (player.playerID != player2.playerID)
{
Collider2D[] hits = new Collider2D[1];
//check lineRenderer for overlapping points
for (int i = 0; i < lineRenderer2.lineRendererPointCount; i++)
{
bool b = false;
Physics2D.OverlapPointNonAlloc(lineRenderer2.gameObject.GetComponent <LineRenderer> ().GetPosition(i), hits, 1);
foreach (Collider2D coll in hits)
{
if (coll != null && movement2.myFlyStatus == MovementComponent.FlyStatus.flying)
{
string collTag;
if (player2.playerID == 1)
{
collTag = "Player2";
}
else if (player2.playerID == 2)
{
collTag = "Player";
}
else
{
collTag = "none";
}
if (coll.tag == collTag)
{
DamageEvent e = new DamageEvent(player.playerID, true);
Debug.Log("Damage Event called cause line renderer overlap for player " + player.playerID);
EgoEvents <DamageEvent> .AddEvent(e);
EgoEvents <DamageEvent> .AddEvent(e); //cause hacking skills are true
b = true;
break;
}
}
}
if (b)
{
break;
}
}
}
});
}
});
}
void Handle(TickEvent e)
{
constraint.ForEachGameObject((egoComponent, transform, movement) =>
{
movement.currentMovement = movement.nextMovement;
if (!e.reverse)
{
var commandEvent = new CommandEvent(new MovementCommand(transform, movement.currentMovement, movement), 0);
EgoEvents <CommandEvent> .AddEvent(commandEvent);
}
});
}
public override CompletionState Act(EgoComponent root)
{
Hardpoint hardpoint;
if (root.TryGetComponents(out hardpoint) && hardpoint.Attached != null)
{
EgoEvents <DetachEvent> .AddEvent(new DetachEvent(hardpoint.Attached));
return(CompletionState.SUCCESS);
}
return(CompletionState.FAIL);
}
protected override void Execute()
{
edible.gameObject.SetActive(false);
//TODO this should be handled by the edibles strategy instead
SnakePartComponent snakePart;
if (mouth.TryGetComponents(out snakePart))
{
var pregEvent = new PregnancyEvent(snakePart);
EgoEvents <PregnancyEvent> .AddEvent(pregEvent);
}
}
void Handle(CountDownEvent e)
{
constraint.ForEachGameObject((egoComponent, mainMenuComponent) => {
mainMenuComponent.myMenuStatus = MainMenuComponent.MenuStatus.inactive;
egoComponent.gameObject.SetActive(false);
});
InitializeNewGameEvent newGame = new InitializeNewGameEvent();
EgoEvents <InitializeNewGameEvent> .AddEvent(newGame);
Debug.Log("started new game");
}
public override void FixedUpdate()
{
constraint.ForEachGameObject((egoComponent, transform, lineRenderer, lineRendererComponent) => {
lineRendererComponent.timeElapsed += Time.deltaTime;
if (lineRendererComponent.lineRendererTimeThreshold <= lineRendererComponent.timeElapsed)
{
var e = new LineRendererDrawEvent();
EgoEvents <LineRendererDrawEvent> .AddEvent(e);
lineRendererComponent.timeElapsed -= lineRendererComponent.lineRendererTimeThreshold;
}
});
}
void Handle(CollisionEnter2DEvent e)
{
Debug.Log("Enter Collision Event");
constraint.ForEachGameObject((egoComponent, spriteRenderer, collisionComponent, lineRenderer, movement, player) => {
SpriteRenderer shipSprite;
PlayerComponent playerC;
//Return if colliding Object has no SpriteRenderer
if (!e.egoComponent1.TryGetComponents(out shipSprite))
{
return;
}
//Else change Sprite to Explosion, if you collided with a spaceship
else if (e.egoComponent2.TryGetComponents(out playerC) && e.egoComponent1.TryGetComponents(out playerC))
{
//e.egoComponent1.GetComponent<SpriteRenderer>().sprite = collisionComponent.explodingSprite;
if (e.egoComponent1.GetComponent <MovementComponent>().myFlyStatus == MovementComponent.FlyStatus.flying &&
e.egoComponent2.GetComponent <MovementComponent>().myFlyStatus == MovementComponent.FlyStatus.flying)
{
var ev = new DamageEvent(player.playerID, false);
Debug.Log("Damage Event called cause players collided");
EgoEvents <DamageEvent> .AddEvent(ev);
}
//Unschön, vielleicht geht das ja auch aus dem DamageEvent heraus?
/*MovementComponent movementComponent;
* if (!e.egoComponent1.TryGetComponents(out movementComponent)) {
* return;
* }
* else {
* movementComponent.myFlyStatus = MovementComponent.FlyStatus.notFlying;
* }*/
}
PowerUpComponent powerup;
if (!e.egoComponent2.TryGetComponents(out powerup))
{
return;
}
else if (e.egoComponent2.TryGetComponents(out powerup))
{
Debug.Log("powerup collected");
Ego.AddComponent <HasSpeedUpComponent>(e.egoComponent1);
e.egoComponent1.GetComponent <PlayerPowerUpComponent>().playerPowerUpTimer = 0;
//e.egoComponent2.gameObject.SetActive(false);
e.egoComponent2.gameObject.GetComponent <SpriteRenderer>().enabled = false;
e.egoComponent2.gameObject.GetComponent <CircleCollider2D>().enabled = false;
var ev = new OnSpeedUpPickUp(e.egoComponent1.GetComponent <PlayerComponent>().playerID);
EgoEvents <OnSpeedUpPickUp> .AddEvent(ev);
}
});
}
public static EgoComponent AddGameObject(GameObject gameObject)
{
var egoComponent = gameObject.GetComponent <EgoComponent>();
if (!egoComponent)
{
egoComponent = gameObject.AddComponent <EgoComponent>();
}
egoComponent.CreateMask();
EgoEvents <AddedGameObject> .AddEvent(new AddedGameObject( gameObject, egoComponent ));
return(egoComponent);
}
public override void Update()
{
constraint.ForEachGameObject((egoComponent, movementInput) => {
float horizontal = Input.GetAxisRaw(movementInput.HorizontalAxis);
float vertical = Input.GetAxisRaw(movementInput.VerticalAxis);
EgoEvents <SetVelocityByEvent> .AddEvent(new SetVelocityByEvent(egoComponent, new Vector2(horizontal, vertical)));
Vector2 cursorPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
float theta = InputUtilities.AngleBetween(egoComponent.transform.position, cursorPos);
EgoEvents <RotateToEvent> .AddEvent(new RotateToEvent(egoComponent, theta));
}
);
}
public static C AddComponent <C>(EgoComponent egoComponent) where C : Component
{
C component = null;
if (!egoComponent.TryGetComponents <C>(out component))
{
component = egoComponent.gameObject.AddComponent <C>();
egoComponent.mask[ComponentIDs.Get(typeof(C))] = true;
EgoEvents <AddedComponent <C> > .AddEvent(new AddedComponent <C>(component, egoComponent));
}
return(component);
}
void Handle(PregnancyEvent e)
{
constraint.ForEachGameObject((egoComponent, transform, snakePart) =>
{
if (e.newParent == snakePart)
{
if (!snakePart.isPregnant)
{
var commandEvent = new CommandEvent(new PregnancyCommand(snakePart, transform.position, true), 0);
EgoEvents <CommandEvent> .AddEvent(commandEvent);
}
}
});
}
public override void Update()
{
constraint.ForEachGameObject((egoComponent, tick) =>
{
if (tick.reverse && tick.currentTick < 1)
{
tick.reverse = false;
}
if (!tick.pause)
{
tick.partialTick += Time.deltaTime * tick.tickRate;
if (tick.partialTick >= 1f)
{
if (!tick.reverse)
{
tick.currentTick++;
}
else
{
tick.currentTick--;
}
tick.partialTick = 0;
var e = new TickEvent(tick.currentTick, tick.reverse);
EgoEvents <TickEvent> .AddEvent(e);
}
}
else
{
if (tick.debugStep == true)
{
tick.debugStep = false;
if (!tick.reverse)
{
tick.currentTick++;
}
else
{
tick.currentTick--;
}
var e = new TickEvent(tick.currentTick, tick.reverse);
EgoEvents <TickEvent> .AddEvent(e);
}
}
});
}
