public void PickupFlag(FlagController flagController)
{
flag = flagController;
flagController.gameObject.transform.SetParent(transform);
flagController.gameObject.transform.localPosition = Vector3.zero;
}
public void ScoreFlag()
{
// Deparent before resetting position
flag.gameObject.transform.SetParent(null);
flag.Reset();
flag = null;
}
public Room(List <Door> doors, GameObject container, Vector2Int gridPosition, bool bossRoom)
{
Doors = doors;
RealPosition = container.transform.position;
GridPosition = gridPosition;
roomGameObject = container;
ConnectedRoomDictionary = new Dictionary <string, Room>(4);
HasDoor = new Dictionary <string, bool>(4);
_controller = GameObject.FindWithTag("Manager").GetComponent <FlagController>();
enemies = new List <GameObject>();
boss = new List <GameObject>();
//Ugly manual setting for each type of entrance
ConnectedRoomDictionary[_controller.DoorUp.name] = null;
HasDoor[_controller.DoorUp.name] = false;
ConnectedRoomDictionary[_controller.DoorDown.name] = null;
HasDoor[_controller.DoorDown.name] = false;
ConnectedRoomDictionary[_controller.DoorLeft.name] = null;
HasDoor[_controller.DoorLeft.name] = false;
ConnectedRoomDictionary[_controller.DoorRight.name] = null;
HasDoor[_controller.DoorRight.name] = false;
foreach (var door in doors)
{
HasDoor[door.type.name] = true;
}
this.bossRoom = bossRoom;
}
internal override void OnEventPlayerDeath(EventManager.BaseEventPlayer victim, EventManager.BaseEventPlayer attacker = null, HitInfo info = null)
{
if (victim == null)
{
return;
}
if ((victim as CaptureTheFlagPlayer).IsCarryingFlag)
{
FlagController flagController = victim.Team == EventManager.Team.B ? TeamAFlag : TeamBFlag;
if (flagController.FlagHolder == victim)
{
flagController.DropFlag(true);
BroadcastToPlayers(GetMessage, "Notification.FlagDropped", victim.Player.displayName, flagController.Team, GetTeamColor(victim.Team), GetTeamColor(flagController.Team));
}
}
victim.OnPlayerDeath(attacker, Configuration.RespawnTime);
if (attacker != null && victim != attacker && victim.Team != attacker.Team)
{
attacker.OnKilledPlayer(info);
}
UpdateScoreboard();
base.OnEventPlayerDeath(victim, attacker);
}
public void Initialize()
{
roomGrid = LevelGenerator.RoomGrid;
gridHeightWidth = gameObject.GetComponent <LevelGenerator>().gridWidthHeight;
_controller = GameObject.FindWithTag("Manager").GetComponent <FlagController>();
_levelManager = LevelManager.Instance;
}
internal override void InitializeEvent(IEventPlugin plugin, EventManager.EventConfig config)
{
flagRespawnTime = config.GetParameter <int>("flagRespawnTimer");
base.InitializeEvent(plugin, config);
TeamAFlag = FlagController.Create(this, EventManager.Team.A, _spawnSelectorA.ReserveSpawnPoint(0));
TeamBFlag = FlagController.Create(this, EventManager.Team.B, _spawnSelectorB.ReserveSpawnPoint(0));
}
internal static FlagController Create(CaptureTheFlagEvent captureTheFlagEvent, EventManager.Team team, Vector3 position)
{
Signage signage = Spawn(position);
FlagController flagController = signage.gameObject.AddComponent <FlagController>();
flagController.captureTheFlagEvent = captureTheFlagEvent;
flagController.Team = team;
flagController.basePosition = position;
return(flagController);
}
void Awake()
{
if (GetComponent <FlagController>() != null)
{
flagController = GetComponent <FlagController>();
}
if (GetComponent <PuzzleController>() != null)
{
puzzleController = GetComponent <PuzzleController>();
}
StartButtonUI.GetComponent <Button>().onClick.AddListener(PushStartButton);
}
private void Awake()
{
if (Instance != null)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
_flags = new Dictionary <string, bool>();
}
public void Init(FlagController flagController)
{
allSRs = gameObject.FindComponents <SpriteRenderer>(true);
//Register delegates for updating artifact sprites
for (int i = 0; i < flagController.pedestalList.Count; i++)
{
Pedestal pdstl = flagController.pedestalList[i];
SpriteRenderer slot = artifactSlots[i];
pdstl.onArtifactChanged +=
(artifact) => UpdateArtifactSlot(slot, artifact);
UpdateArtifactSlot(slot, null);// pdstl.Artifact);
}
//Register delegate for showing/hiding
gameObject.FindComponent <MapMarker>().onShow +=
(show) => allSRs.ForEach(sr => sr.enabled = show);
}
private void Start()
{
I = this;
Messages = new GameEventDispatcher();
SystemController = new SystemController();
EntityManager = new EntityController();
EntitySpawner = new EntitySpawner();
MapController.Init();
UserInputController.Init();
GameUI.Init();
flagController = new FlagController();
EntitySpawner.StartGame();
}
private void Awake()
{
lock (padlock)
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
//Here any additional initialization should occur:
}
}
//DontDestroyOnLoad(this.gameObject);
}
private void OnTriggerEnter(Collider col)
{
if (captureTheFlagEvent.Status != EventManager.EventStatus.Started)
{
return;
}
CaptureTheFlagPlayer eventPlayer = col.GetComponent <CaptureTheFlagPlayer>();
if (eventPlayer == null || eventPlayer.IsDead)
{
return;
}
if (IsAtBase)
{
if (eventPlayer.Team != Team)
{
PickupFlag(eventPlayer);
}
else
{
if (eventPlayer.IsCarryingFlag)
{
FlagController enemyFlag = Team == EventManager.Team.A ? captureTheFlagEvent.TeamBFlag : captureTheFlagEvent.TeamAFlag;
enemyFlag.CaptureFlag(eventPlayer);
}
}
}
else
{
if (FlagHolder == null)
{
if (eventPlayer.Team != Team)
{
PickupFlag(eventPlayer);
}
else
{
ResetFlag();
captureTheFlagEvent.BroadcastToPlayers(GetMessage, "Notification.FlagReset", eventPlayer.Team, captureTheFlagEvent.GetTeamColor(eventPlayer.Team));
}
}
}
}
private void SpawnFlag()
{
if (_flag != null && _grassList.Count != 0)
{
int instantiateFlagRightSide = Random.Range(_grassList.Count / 2, _grassList.Count - 1);
colliderGrass = _grassList[instantiateFlagRightSide].GetComponent <Collider2D>();
colliderGrass.isTrigger = true;
flagInstantiate = Instantiate(_flag, _grassList[instantiateFlagRightSide]);
FlagController flagController = flagInstantiate.transform.GetComponentInChildren <FlagController>();
if (flagController != null)
{
flagController.SetGameManager(GetComponent <GameManager>());
}
}
}
public void OnTriggerEnter2D(Collider2D other)
{
if (other.gameObject.CompareTag("Coin"))
{
catchCoin(other.gameObject);
}
else if (other.gameObject.CompareTag("RedFlag"))
{
spawnPoint.position = other.gameObject.transform.position;
FlagController flagController = other.gameObject.GetComponent <FlagController>();
if (flagController != null)
{
flagController.check();
}
}
else if (other.gameObject.CompareTag("RedDiamond"))
{
catchRedDiamond(other.gameObject);
}
else if (other.gameObject.CompareTag("BossPhase"))
{
enterBossPhase(other.gameObject);
}
else if (other.gameObject.CompareTag("Enemy"))
{
print("OnCollisionEnter2D Enemy");
if (_rigidbody.velocity.y < 0f)
{
EnemyController enemyController = other.gameObject.GetComponent <EnemyController>();
if (enemyController != null)
{
enemyController.damage();
}
}
}
}
private void StartFlag()
{
//disable guessing while flaground
UpdateGuessingStatus(false);
//Debug.Log("StartFlag called");
//Bättre att ha statiska som lyses upp i en sequence än att skapa o döda
GameObject flag = Instantiate(flagPrefab);
//flag.GetComponent<FlagController>().lastFlagPos = lastFlagPos;
//nrFlagsShown++;
//give the flagcontroller the flagorganizerts "id", so we can update FO from FC
FlagController flagController = flag.GetComponentInChildren <FlagController>();
flagController.flagOrganizer = this;
//Tell the flagcontroller how many flags to show this round
flag.GetComponent <FlagController>().maxNrFlagsToShow = maxNrFlagsToShowThisRound;
gameManager.UpDateRoundNrDisplay(maxNrFlagsToShowThisRound);
maxNrFlagsToShowThisRound++;
}
// Start is called before the first frame update
void Start()
{
_controller = GetComponent <FlagController>();
_spawnController = GetComponent <SpawnController>();
//Grid init
RoomGrid = new Room[gridWidthHeight, gridWidthHeight];
roomsToGen = roomGenNumber;
startingGridPostion = new Vector2Int(gridWidthHeight / 2, gridWidthHeight / 2);
Debug.Log("Starting grid location " + startingGridPostion.ToString());
deltaVectors = _controller.deltaVectors;
directionsDelta = _controller.directionsDelta;
//Create main room on grid
var homeRoom = SetupMainRoom();
var playerGameObject = GameObject.FindWithTag("Player");
if (playerGameObject == null)
{
playerGameObject = _spawnController.SpawnPlayerInRoomCenter(homeRoom);
}
else
{
SpawnController.MoveObjectToRoomCenter(playerGameObject, homeRoom);
}
//We get the modifier that we have to multiply delta movement by because of how Tiler scales things
modifier = _gridGameObject.GetComponent <Grid>().cellSize;
//Loading all the saved room prefabs
var _roomGameObjects = LoadGameObjectRooms();
GameObjectRoomsByExits = SortGameObjectRoomsBySize(_roomGameObjects);
var actionList = new[]
{
new Action(() =>
{
GenerateRoomsNew(startingGridPostion.x + deltaVectors[0].x,
startingGridPostion.y + deltaVectors[0].y, directionsDelta[0], homeRoom, branchMaxLength);
}),
new Action(() =>
{
GenerateRoomsNew(startingGridPostion.x + deltaVectors[1].x,
startingGridPostion.y + deltaVectors[1].y, directionsDelta[1], homeRoom, branchMaxLength);
}),
new Action(() =>
{
GenerateRoomsNew(startingGridPostion.x + deltaVectors[2].x,
startingGridPostion.y + deltaVectors[2].y, directionsDelta[2], homeRoom, branchMaxLength);
}),
new Action(() =>
{
GenerateRoomsNew(startingGridPostion.x + deltaVectors[3].x,
startingGridPostion.y + deltaVectors[3].y, directionsDelta[3], homeRoom, branchMaxLength);
})
}.ToList();
Shuffle(actionList);
for (int i = 0; i < actionList.Count; i++)
{
var action = actionList[i];
action();
}
PatchLeftovers();
/**
* //Pretty print
* int rowLength = RoomGrid.GetLength(0);
* int colLength = RoomGrid.GetLength(1);
* string arrayString = "";
* for (int i = 0; i < rowLength; i++)
* {
* for (int j = 0; j < colLength; j++)
* {
* arrayString += string.Format("{0} ", RoomGrid[i, j] == null ? "None" : RoomGrid[i,j].roomGameObject.name);
* arrayString += " ";
* }
* arrayString += Environment.NewLine + Environment.NewLine;
* }
**/
AddNavMeshModifierToWalls();
AddNavMeshModifierToPillars();
AddTagToEveryRoomWall();
AddTagToEveryRoomPillar();
BakeNavMesh();
gameObject.GetComponent <SpawnController>().Initialize();
gameObject.GetComponent <SpawnController>().SpawnForAllRooms();
if (!gameObject.GetComponent <SpawnController>().bossSpawned)
{
var spawnController = gameObject.GetComponent <SpawnController>();
foreach (var room in spawnController.roomGrid)
{
if (room != null)
{
spawnController.ForceSpawnBoss(room.GridPosition);
Debug.LogWarning("Force spawned");
break;
}
}
}
gameObject.GetComponent <LocationController>()
.Initialize(startingGridPostion, RoomGrid, playerGameObject, gameObject.GetComponent <SpawnController>());
gameObject.GetComponent <KillQuestController>().Init();
RemoveFlagRendering();
_roomGameObjects.ForEach(room => Destroy(room));
Debug.Assert(madeBossRoom);
}
public void setFlagController(FlagController control)
{
ctrFlag = control;
}
public static FlagController Fixture()
{
FlagController controller = new FlagController(new FlagRepository(), "", new LoginView());
return(controller);
}
public void DropFlag()
{
flag.gameObject.transform.SetParent(null);
flag = null;
}
private void Awake()
{
Instance = this;
}
void Start()
{
fc = transform.parent.gameObject.GetComponent <FlagController>();
}
void resetGame()
{
Debug.Log("resetGame");
// Clear game area
if (CurrentGameMap != null)
{
Destroy(CurrentGameMap.gameObject);
}
players.Clear();
// Pick a random map
CurrentGameMap = Instantiate(GameMaps[Random.Range(0, GameMaps.Length)]);
List <Color> colors = new List <Color> {
Color.red, Color.blue, Color.green, Color.yellow
};
List <string> colorNames = new List <string> {
"Red", "Blue", "Green", "Yellow"
};
for (int i = 0; i < NUM_PLAYERS; i++)
{
Vector3 pos = CurrentGameMap.GetSpawnPosition(GenMinSceneryDistance, GenMinDistance, GenMaxDistance, CurrentGameMap.CannonPlacementMap);
// TODO implement dynamic cannon height (0 - 0.39)
pos.y -= 0.39f;
float dir = Random.Range(0, 360);
GameObject cannon = (GameObject)Instantiate(CannonPrefab, pos, Quaternion.Euler(0, dir, 0));
cannon.transform.parent = CurrentGameMap.WorldContainer.transform;
Player player = new Player();
player.Id = i;
player.Cannon = cannon;
int colorIndex = Random.Range(0, colors.Count);
player.Color = colors[colorIndex];
player.ColorName = colorNames[colorIndex];
FlagController flag = cannon.GetComponentInChildren <FlagController>();
flag.gameObject.GetComponent <MeshRenderer>().material.color = player.Color;
CannonController cannonController = cannon.GetComponentInChildren <CannonController>();
cannonController.OnCannonFired = delegate { cannonController.FiringEnabled = false; };
cannonController.OnCannonExploded = delegate { OnCannonDestroyed(player.Cannon); };
cannonController.OnMissileExploded = delegate { StartCoroutine(changeTurnDelayed()); };
cannonController.Player = player;
colors.RemoveAt(colorIndex);
colorNames.RemoveAt(colorIndex);
player.CurrentTeleportIndex = 0;
players.Add(player);
Debug.Log("created player [" + player.Id + ", " + player.ColorName + "] cannon at " + player.Cannon.transform.position.ToString("f4") + ", rot: " + player.Cannon.transform.eulerAngles.ToString("f4"));
}
// Generate waypoints for players
foreach (Player p in players)
{
// Cannon location
Teleport.TeleportLocation t = new Teleport.TeleportLocation();
t.Position = p.Cannon.transform.position;
// TODO account for dynamic height once such is implemented
t.Position.y += 0.39f;
p.TeleportLocations.Add(t);
// Bird view locations, one per opponent
foreach (Player p2 in players)
{
if (p != p2)
{
t = new Teleport.TeleportLocation();
Vector3 p2p = p2.Cannon.transform.position - p.Cannon.transform.position;
Vector3 perp = Vector3.Cross(p2p, new Vector3(0, 1, 0)).normalized;
t.Position = p.Cannon.transform.position + p2p * 0.5f + perp * (p2p.magnitude / 2);
t.Position.y = CurrentGameMap.Terrain.SampleHeight(new Vector3(t.Position.x, 0, t.Position.z)) + 80;
Vector3 toCannon = p.Cannon.transform.position - t.Position;
toCannon.y = 0;
toCannon.Normalize();
t.Rotation = Quaternion.LookRotation(toCannon);
t.ForceRotation = true;
p.TeleportLocations.Add(t);
}
}
}
// Spawn scenery objects
CurrentGameMap.SpawnSceneryObjects();
gameOver = false;
changeTurn();
}
public static FlagController Fixture()
{
FlagController controller = new FlagController(new FlagRepository());
return controller;
}
private List <List <float> > _ParseMap(IEnumerator <string> se)
{
InGameCommon gameController = InGameCommon.CurrentGame;
Teams teams = gameController.GetComponent <Teams>();
// game mode
// 0 - capture the flag
int gameMode = int.Parse(_Take(se));
// number of teams - n
int numTeams = int.Parse(_Take(se));
// n team colors
{
List <Color> colors = new List <Color>(numTeams);
for (int i = 0; i < numTeams; ++i)
{
Color color = new Color();
color.r = float.Parse(_Take(se));
color.g = float.Parse(_Take(se));
color.b = float.Parse(_Take(se));
color.a = 1.0f;
colors.Add(color);
}
teams.Colors = colors;
}
// n team spawn spefications
{
List <InGameCommon.SpawnList> spawns = new List <InGameCommon.SpawnList>(numTeams);
for (int i = 0; i < numTeams; ++i)
{
int numSpawns = int.Parse(_Take(se));
InGameCommon.SpawnList teamSpawns = new InGameCommon.SpawnList {
Spawns = new List <SpawnPoint>(numSpawns)
};
for (int j = 0; j < numSpawns; ++j)
{
float x = float.Parse(_Take(se)) * PrismScale;
float y = float.Parse(_Take(se)) * PrismScale;
GameObject spawn = Instantiate(
PlayerSpawnPrefab, new Vector3(x, 0.0f, y), Quaternion.identity
);
teamSpawns.Spawns.Add(spawn.GetComponent <SpawnPoint>());
}
spawns.Add(teamSpawns);
}
gameController.TeamSpawns = spawns;
}
if (gameMode == 0)
{
FlagController flagController = gameController.GetComponent <FlagController>();
// flag zones
for (int i = 0; i < numTeams; ++i)
{
int numFlagZones = int.Parse(_Take(se));
for (int j = 0; j < numFlagZones; ++j)
{
float x = float.Parse(_Take(se)) * PrismScale;
float y = float.Parse(_Take(se)) * PrismScale;
float radius = float.Parse(_Take(se));
Transform t =
Instantiate(FlagZonePrefab, new Vector3(x, 0.0f, y), Quaternion.identity).transform;
t.localScale = new Vector3(radius, 100.0f, radius);
t.GetComponent <FlagZone>().Team = i;
}
}
// flag spawns
int numFlagSpawns = int.Parse(_Take(se));
{
List <SpawnPoint> spawns = new List <SpawnPoint>(numFlagSpawns);
for (int i = 0; i < numFlagSpawns; ++i)
{
float x = float.Parse(_Take(se)) * PrismScale;
float y = float.Parse(_Take(se)) * PrismScale;
GameObject spawn = Instantiate(
FlagSpawnPrefab, new Vector3(x, 0.0f, y), Quaternion.identity
);
spawns.Add(spawn.GetComponent <SpawnPoint>());
}
flagController.Spawns = spawns;
}
}
// map properties
NumPrismsX = int.Parse(_Take(se));
NumPrismsZ = int.Parse(_Take(se));
MinHeight = float.Parse(_Take(se));
MaxHeight = float.Parse(_Take(se));
// initial tile heights
List <List <float> > heights = new List <List <float> >(NumPrismsZ);
for (int z = 0; z < NumPrismsZ; ++z)
{
List <float> row = new List <float>(NumPrismsX);
for (int x = 0; x < NumPrismsX; ++x)
{
row.Add(float.Parse(_Take(se)));
}
heights.Add(row);
}
return(heights);
}
