public void Awake()
{
var blueTeam = GameObject.Find("Team_Blue").GetComponent <Team>();
var redTeam = GameObject.Find("Team_Red").GetComponent <Team>();
blueTeam.AddPlayer(this);
redTeam.AddPlayer(this);
Teams.Add(blueTeam);
Teams.Add(redTeam);
LocalPlayer = gameObject.AddComponent <PlayerBehaviour>();
LocalPlayer.Data = redTeam.Players[0];
GameObject.Find("Managers").GetComponent <DeploymentMenu>().LocalPlayer = LocalPlayer;
_inputManager = FindObjectOfType <InputManager>() ??
gameObject.AddComponent <InputManager>();
_visibilityManager = FindObjectOfType <VisibilityManager>() ??
gameObject.AddComponent <VisibilityManager>();
_inputManager.Session = _inputManager.Session ?? this;
_visibilityManager.LocalTeam = _visibilityManager.LocalTeam ?? LocalPlayer.Data.Team;
// TODO: Pass terrain from future location of starting matches (no Find)
PathData = new PathfinderData(GameObject.Find("Terrain").GetComponent <Terrain>());
Factory = new UnitFactory(this);
Settings = new Settings();
}
public void SetActiveSearchCritera()
{
if (SearchCriteriaSelectedIndex == 0)
{
PopulateRetreivedRecordsLedgerFromSearchCriteria = new ListReceivingRecordsByDateRangeCommand(this);
VisibilityManager.SetVisibility(SearchCriteriaVisibilityManager.ActiveCriteriaPanel.DateRange);
}
if (SearchCriteriaSelectedIndex == 1)
{
PopulateRetreivedRecordsLedgerFromSearchCriteria = new ListReceivingRecordsByDatePeriodCommand(this);
VisibilityManager.SetVisibility(SearchCriteriaVisibilityManager.ActiveCriteriaPanel.DatePeriod);
}
if (SearchCriteriaSelectedIndex == 2)
{
PopulateRetreivedRecordsLedgerFromSearchCriteria = new ListReceivingRecordsBySpecificDateCommand(this);
VisibilityManager.SetVisibility(SearchCriteriaVisibilityManager.ActiveCriteriaPanel.SpecificDate);
}
if (SearchCriteriaSelectedIndex == 3)
{
PopulateRetreivedRecordsLedgerFromSearchCriteria = new ListReceivingRecordsByPONumberCommand(this);
VisibilityManager.SetVisibility(SearchCriteriaVisibilityManager.ActiveCriteriaPanel.PONumber);
}
NotifyPropertyChanged("PopulateRetreivedRecordsLedgerFromSearchCriteria");
}
private void BringStaticPanelIntoViewInternal(IStaticPanelDefinition definition)
{
definition.AssertParameterNotNull(nameof(definition));
LayoutAnchorable anchorable = null;
try
{
anchorable = anchorableDefinitions.GetKeysForValue(definition).Single();
}
catch (InvalidOperationException)
{
throw new Exception($"Error : Cannot find a unique registered anchorable associated with the static panel definition " +
$"{definition.IView},{definition.View}, {definition.IViewModel}, {definition.ViewModel}");
}
if (anchorable.IsHidden && definition.CanChangeVisibility(false))
{
VisibilityManager.SetVisibility(anchorable, true);
}
else
{
var group = anchorable.Parent.SafeCast <LayoutAnchorablePane>();
group.SelectedContentIndex = group.Children.IndexOf(anchorable);
}
}
private void InvalidateStaticPanel(IStaticPanelDefinition definition)
{
if (!IsUILoaded)
{
return;
}
var anchorable = anchorableDefinitions.GetKeysForValue(definition).Single();
var config = definition.OfType <StaticPanelConfiguration>().Single();
var canOpen = config.CanOpen();
var canClose = config.CanClose();
if (canOpen == false && canClose == false)
{
throw new Exception($"Error invaidating static panel {definition.ViewModel}. CanOpen() and CanClose() defined " +
$"in the panel definition's configuration metadata can't both return false at the same time.");
}
if (!canOpen && !anchorable.IsHidden)
{
VisibilityManager.SetVisibility(anchorable, false);
}
else if (!canClose && anchorable.IsHidden)
{
VisibilityManager.SetVisibility(anchorable, true);
}
anchorable.Title = config.Title();
EventAggregator.GetEvent <StaticPanelInvalidationEvent>().Publish(new StaticPanelInvalidationArgs(definition));
}
private void Awake()
{
Current = this;
_networkManager = FindObjectOfType <NetworkManager>();
Team blueTeam = GameObject.Find("Team_Blue").GetComponent <Team>();
Team redTeam = GameObject.Find("Team_Red").GetComponent <Team>();
Deck bluePlayerDeck = ConfigReader.FindDeck("player-blue");
Deck redPlayerDeck = ConfigReader.FindDeck("player-red");
PlayerData bluePlayer = new PlayerData(
bluePlayerDeck, blueTeam, (byte)Players.Count);
Players.Add(bluePlayer);
blueTeam.Players.Add(bluePlayer);
PlayerData redPlayer = new PlayerData(
redPlayerDeck, redTeam, (byte)Players.Count);
Players.Add(redPlayer);
redTeam.Players.Add(redPlayer);
Teams.Add(blueTeam);
Teams.Add(redTeam);
LocalPlayer = gameObject.AddComponent <PlayerBehaviour>();
LocalPlayer.Data = redTeam.Players[0];
_unitRegistry = new UnitRegistry(LocalPlayer.Data.Team, Teams);
_inputManager = FindObjectOfType <InputManager>();
if (!_inputManager)
{
_inputManager = gameObject.AddComponent <InputManager>();
}
_inputManager.Session = _inputManager.Session ?? this;
_visibilityManager = FindObjectOfType <VisibilityManager>();
if (!_visibilityManager)
{
_visibilityManager = gameObject.AddComponent <VisibilityManager>();
}
_visibilityManager.UnitRegistry = _visibilityManager.UnitRegistry ?? _unitRegistry;
_deploymentMenu.Initialize(_inputManager, LocalPlayer);
// LoadedData ideally comes from the loading scene
_loadedData = FindObjectOfType <LoadedData>();
if (_loadedData != null)
{
TerrainMap = _loadedData.terrainData;
PathData = _loadedData.pathFinderData;
Factory = new UnitFactory();
Settings = new Settings();
}
}
// Token: 0x060010B1 RID: 4273 RVA: 0x0006DAF0 File Offset: 0x0006BEF0
private void OnApplicationQuit()
{
DevkitWindowLayout.save("Default");
VisibilityManager.save();
DevkitSelectionToolOptions.save();
DevkitLandscapeToolHeightmapOptions.save();
DevkitLandscapeToolSplatmapOptions.save();
DevkitFoliageToolOptions.save();
}
/// <summary>
/// Respawns enemy ships according to the fleet of the player and the number of remaining enemy ships.
/// </summary>
// ReSharper disable once UnusedMember.Global
private void RespawnShips()
{
if (GhostShip != null)
{
return;
}
var randomNumber = new Random();
var mapParts = RessourceManager.GetRessourceInt("mapParts");
if (mAiFisherShipList.Count < 12)
{
//spawn Fisherships until there are enough
//random position
var spawnPosition = new Vector2(randomNumber.Next(200, 5600), randomNumber.Next(200, 5600));
var cell = Game1.mMapScreen.mGridMap.GetCell(spawnPosition);
if (cell.IsWalkable && !cell.Occupied && !VisibilityManager.IsVisible(spawnPosition))
{
SpawnAiFisherShip(spawnPosition);
}
}
if (mAiTradingShipList.Count < 7)//static number of tradingships
{
//spawn
var spawnPosition = new Vector2(randomNumber.Next(300, 5600), randomNumber.Next(300, 5600));
var cell = Game1.mMapScreen.mGridMap.GetCell(spawnPosition);
if (cell.IsWalkable && !cell.Occupied && !VisibilityManager.IsVisible(spawnPosition))
{
SpawnAiTradingShip(spawnPosition);
}
}
if (mAiBattleShipsList.Count < 2 + mapParts * 3)//by collecting more mapParts, the count of battleships increases
{
//spawn
var spawnPosition = new Vector2(randomNumber.Next(400, 5600), randomNumber.Next(400, 5600));
var cell = Game1.mMapScreen.mGridMap.GetCell(spawnPosition);
if (cell.IsWalkable && !cell.Occupied && !VisibilityManager.IsVisible(spawnPosition))
{
SpawnAiBattleShip(spawnPosition);
}
}
if (mAiFleetList.Count < mapParts - 2 && mAiFleetList.Count < 3)// only up to 3 fleets
{
//random SpawnPoint from List.
var spawnPosition = mFleetSpawnPoints[randomNumber.Next(0, mFleetSpawnPoints.Count - 1)];
if (mapParts < 3)
{
SpawnAiFleet(spawnPosition, 2, 1);
}
else
{
SpawnAiFleet(spawnPosition, 3, 2);//increase strength of the fleets
}
}
}
private void Start()
{
_anim = GetComponentInChildren <Animator>();
_visibilityManager = GetComponent <VisibilityManager>();
_visibilityManager.ObjectOffScreen += OnOffScreen;
Main.Instance.PauseToggled += OnPauseToggled;
}
static SpawnpointSystem()
{
SpawnpointSystem.spawnpointVisibilityGroup = VisibilityManager.registerVisibilityGroup <VisibilityGroup>(SpawnpointSystem.spawnpointVisibilityGroup);
if (SpawnpointSystem.< > f__mg$cache0 == null)
{
SpawnpointSystem.< > f__mg$cache0 = new GLRenderHandler(SpawnpointSystem.handleGLRender);
}
GLRenderer.render += SpawnpointSystem.< > f__mg$cache0;
}
static DeadzoneSystem()
{
DeadzoneSystem.deadzoneVisibilityGroup.color = new Color32(byte.MaxValue, 0, 0, byte.MaxValue);
DeadzoneSystem.deadzoneVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(DeadzoneSystem.deadzoneVisibilityGroup);
if (DeadzoneSystem.< > f__mg$cache0 == null)
{
DeadzoneSystem.< > f__mg$cache0 = new GLRenderHandler(DeadzoneSystem.handleGLRender);
}
GLRenderer.render += DeadzoneSystem.< > f__mg$cache0;
}
static KillVolumeSystem()
{
KillVolumeSystem.killVisibilityGroup.color = new Color32(220, 100, 20, byte.MaxValue);
KillVolumeSystem.killVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(KillVolumeSystem.killVisibilityGroup);
if (KillVolumeSystem.< > f__mg$cache0 == null)
{
KillVolumeSystem.< > f__mg$cache0 = new GLRenderHandler(KillVolumeSystem.handleGLRender);
}
GLRenderer.render += KillVolumeSystem.< > f__mg$cache0;
}
static WaterSystem()
{
WaterSystem.waterVisibilityGroup.color = new Color32(50, 200, 200, byte.MaxValue);
WaterSystem.waterVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(WaterSystem.waterVisibilityGroup);
if (WaterSystem.< > f__mg$cache0 == null)
{
WaterSystem.< > f__mg$cache0 = new GLRenderHandler(WaterSystem.handleGLRender);
}
GLRenderer.render += WaterSystem.< > f__mg$cache0;
}
// Token: 0x060008CE RID: 2254 RVA: 0x0004DBF0 File Offset: 0x0004BFF0
static AmbianceSystem()
{
AmbianceSystem.ambianceVisibilityGroup.color = new Color32(0, 127, 127, byte.MaxValue);
AmbianceSystem.ambianceVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(AmbianceSystem.ambianceVisibilityGroup);
if (AmbianceSystem.< > f__mg$cache0 == null)
{
AmbianceSystem.< > f__mg$cache0 = new GLRenderHandler(AmbianceSystem.handleGLRender);
}
GLRenderer.render += AmbianceSystem.< > f__mg$cache0;
}
// Token: 0x060009BF RID: 2495 RVA: 0x000504DC File Offset: 0x0004E8DC
static EffectVolumeSystem()
{
EffectVolumeSystem.effectVisibilityGroup.color = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
EffectVolumeSystem.effectVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(EffectVolumeSystem.effectVisibilityGroup);
if (EffectVolumeSystem.< > f__mg$cache0 == null)
{
EffectVolumeSystem.< > f__mg$cache0 = new GLRenderHandler(EffectVolumeSystem.handleGLRender);
}
GLRenderer.render += EffectVolumeSystem.< > f__mg$cache0;
}
static FoliageVolumeSystem()
{
FoliageVolumeSystem.foliageVisibilityGroup.color = new Color32(44, 114, 34, byte.MaxValue);
FoliageVolumeSystem.foliageVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(FoliageVolumeSystem.foliageVisibilityGroup);
if (FoliageVolumeSystem.< > f__mg$cache0 == null)
{
FoliageVolumeSystem.< > f__mg$cache0 = new GLRenderHandler(FoliageVolumeSystem.handleGLRender);
}
GLRenderer.render += FoliageVolumeSystem.< > f__mg$cache0;
}
// Update is called once per frame
void Update()
{
var newRegion = VisibilityManager.getRegion(transform);
if (currentRegion != newRegion)
{
//Debug.Log("region updated");
VisibilityManager.updateUnitRegion(this, newRegion);
currentRegion = newRegion;
}
}
void Init()
{
rooms = new List <Room>();
tiles = new TileType[mapSize.y][];
for (int i = 0; i < mapSize.y; i++)
{
tiles[i] = new TileType[mapSize.x];
}
tileRenderer = new TileRenderer(rooms);
visibilityManager = VisibilityManager.GetInstance();
}
static PlayerClipVolumeSystem()
{
PlayerClipVolumeSystem.playerClipVisibilityGroup.color = new Color32(63, 0, 0, byte.MaxValue);
PlayerClipVolumeSystem.playerClipVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(PlayerClipVolumeSystem.playerClipVisibilityGroup);
PlayerClipVolumeSystem.navClipVisibilityGroup = new VolumeVisibilityGroup("nav_clip_volumes", new TranslationReference("#SDG::Devkit.Visibility.Nav_Clip_Volumes"), true);
PlayerClipVolumeSystem.navClipVisibilityGroup.color = new Color32(63, 63, 0, byte.MaxValue);
PlayerClipVolumeSystem.navClipVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(PlayerClipVolumeSystem.navClipVisibilityGroup);
if (PlayerClipVolumeSystem.< > f__mg$cache0 == null)
{
PlayerClipVolumeSystem.< > f__mg$cache0 = new GLRenderHandler(PlayerClipVolumeSystem.handleGLRender);
}
GLRenderer.render += PlayerClipVolumeSystem.< > f__mg$cache0;
}
public ConsoleMenuDisplay(
ItemsCollection menuItems,
IConsole console,
List <string> titles,
MenuConfig config,
CloseTrigger closeTrigger)
{
this.menuItems = menuItems;
this.console = console;
this.titles = titles;
this.config = config;
this.visibility = new VisibilityManager(menuItems.Items.Count);
this.closeTrigger = closeTrigger;
this.noSelectorLine = new string(' ', this.config.Selector.Length);
}
private Dictionary <int, List <GameObject> > levelsDict; // Dictionary storring all GameObjects of each level
void Awake()
{
//Check if instance already exists
if (instance == null)
{
//if not, set instance to this
instance = this;
}
//If instance already exists and it's not this:
else if (instance != this)
{
//Then destroy this. This enforces our singleton pattern, meaning there can only ever be one instance of a GameManager.
Destroy(gameObject);
}
}
/// <summary>
/// Sets a specified byte of an updatefield to the specified value
/// </summary>
/// <param name="field">The field to set</param>
/// <param name="value">The value to set</param>
/// <param name="index">The index of the byte in the 4-byte field. (Ranges from 0-3)</param>
protected void SetByte(int iField, int iIndex, byte byValue)
{
if (m_UpdateValues[iField].GetByte(iIndex) == byValue)
{
return;
}
m_UpdateValues[iField].SetByte(iIndex, byValue);
m_PrivateUpdateMask.SetBit(iField);
if (VisibilityManager.IsPublicField(iField) == true)
{
m_PublicUpdateMask.SetBit(iField);
}
OnRequestUpdate();
}
protected void SetUInt32(int iField, uint uiValue)
{
if (m_UpdateValues[iField].UInt32 == uiValue)
{
return;
}
m_UpdateValues[iField].UInt32 = uiValue;
m_PrivateUpdateMask.SetBit(iField);
if (VisibilityManager.IsPublicField(iField) == true)
{
m_PublicUpdateMask.SetBit(iField);
}
OnRequestUpdate();
}
protected void SetInt16High(int iField, short sValue)
{
if (m_UpdateValues[iField].Int16High == sValue)
{
return;
}
m_UpdateValues[iField].Int16High = sValue;
m_PrivateUpdateMask.SetBit(iField);
if (VisibilityManager.IsPublicField(iField) == true)
{
m_PublicUpdateMask.SetBit(iField);
}
OnRequestUpdate();
}
protected void SetFloat(int iField, float fValue)
{
if (m_UpdateValues[iField].Float == fValue)
{
return;
}
m_UpdateValues[iField].Float = fValue;
m_PrivateUpdateMask.SetBit(iField);
if (VisibilityManager.IsPublicField(iField) == true)
{
m_PublicUpdateMask.SetBit(iField);
}
OnRequestUpdate();
}
static LandscapeHoleSystem()
{
LandscapeHoleSystem._Landscape_Holes_Count = Shader.PropertyToID("_Landscape_Holes_Count");
LandscapeHoleSystem._Landscape_Holes_List = Shader.PropertyToID("_Landscape_Holes_List");
LandscapeHoleSystem.landscapeHoles = new Matrix4x4[LandscapeHoleSystem.MAX_LANDSCAPE_HOLES];
LandscapeHoleSystem.holeVisibilityGroup = new VolumeVisibilityGroup("landscape_hole_volumes", new TranslationReference("#SDG::Devkit.Visibility.Landscape_Hole_Volumes"), true);
LandscapeHoleSystem.holeVisibilityGroup.color = new Color32(71, 44, 20, byte.MaxValue);
LandscapeHoleSystem.holeVisibilityGroup = VisibilityManager.registerVisibilityGroup <VolumeVisibilityGroup>(LandscapeHoleSystem.holeVisibilityGroup);
if (LandscapeHoleSystem.< > f__mg$cache0 == null)
{
LandscapeHoleSystem.< > f__mg$cache0 = new UpdateHandler(LandscapeHoleSystem.handleUpdated);
}
TimeUtility.updated += LandscapeHoleSystem.< > f__mg$cache0;
if (LandscapeHoleSystem.< > f__mg$cache1 == null)
{
LandscapeHoleSystem.< > f__mg$cache1 = new GLRenderHandler(LandscapeHoleSystem.handleGLRender);
}
GLRenderer.render += LandscapeHoleSystem.< > f__mg$cache1;
}
protected override void Awake()
{
base.Awake();
GameSettings = GameSettings.Instance;
UnitObjectManager = GameObject.FindObjectOfType <UnitObjectManager>();
UnitViewManager = GameObject.FindObjectOfType <UnitViewManager>();
InputManager = GameObject.FindObjectOfType <InputManager>();
PartViewsManager = GameObject.FindObjectOfType <PartViewsManager>();
ShotViewsManager = GameObject.FindObjectOfType <ShotViewsManager>();
UnitManager = new UnitManager();
PartsManager = new PartsManager();
TimeManager = new TimeManager();
SelectionManager = new SelectionManager();
CommandManager = new CommandManager();
InputContextManager = new InputContextManager();
PlayerManager = new PlayerManager();
VisibilityManager = new VisibilityManager();
ShotsManager = new ShotsManager();
_managers[UnitManager.ManagerType] = UnitManager;
_managers[UnitViewManager.ManagerType] = UnitViewManager;
_managers[UnitObjectManager.ManagerType] = UnitObjectManager;
_managers[InputManager.ManagerType] = InputManager;
_managers[SelectionManager.ManagerType] = SelectionManager;
_managers[CommandManager.ManagerType] = CommandManager;
_managers[TimeManager.ManagerType] = TimeManager;
_managers[InputContextManager.ManagerType] = InputContextManager;
_managers[PlayerManager.ManagerType] = PlayerManager;
_managers[VisibilityManager.ManagerType] = VisibilityManager;
_managers[ShotsManager.ManagerType] = ShotsManager;
_managers[ShotViewsManager.ManagerType] = ShotViewsManager;
_managers[PartsManager.ManagerType] = PartsManager;
_managers[PartViewsManager.ManagerType] = PartViewsManager;
foreach (var manager in _managers.Values)
{
manager.Init();
}
}
void Start()
{
visibilityManager = VisibilityManager.Instance;
selfEntity = GetComponentInParent <Entity>();
myVisionCollider = GetComponentsInChildren <Collider>().Where(x => visionMask == (visionMask | (1 << x.gameObject.layer))).FirstOrDefault();
visionMask = LayerManager.Instance.visionTargetMask;
obstacleMask = LayerManager.Instance.visionBlockerMask;
isClient = NetworkStatus.Instance.IsClient;
if (isClient)
{
viewMesh = new Mesh {
name = "View Mesh"
};
viewMeshFilter.mesh = viewMesh;
}
StartCoroutine("FindTargetsWithDelay", .2f);
}
public IEnumerator SegmentsClockwiseNE()
{
//Instantiate objects
//GameObject gameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/VisibilityManager"));
visibilityManager = new VisibilityManager();
//Create segments
Vector3[] segment = { new Vector3(1, 4), new Vector3(2, 0, 2) };
//Create origin
Vector3 origin = new Vector3(1, 0, 1);
//Give segments to program
//get response
//Assert.IsTrue(visibilityManager.Isclockwise(segment, origin));
yield return(new WaitForSeconds(0.1f));
Object.Destroy(visibilityManager.gameObject);
}
public void initialize(Team t)
{
team = t;
var o = Team.Blue;
if (t == Team.Blue)
{
o = Team.Red;
}
setHostileTeam(VisibilityManager.getTeamMembers(o));
VisibilityManager.addVisibleBehaviour(this);
if (team == Team.Red)
{
GetComponent <Renderer>().material.color = Color.red;
}
else
{
GetComponent <Renderer>().material.color = Color.blue;
}
updateTeamBelonging();
currentRegion = VisibilityManager.getRegion(transform);
VisibilityManager.updateUnitRegion(this, currentRegion);
}
public void onClick()
{
UIManagerBehaviour.currentTeam = team;
VisibilityManager.updateTeamBelonging();
}
