public EnemyShipController PrefabInstantiate(PlanetController planet, Vector2 orbit, Vector2 position, bool immobile)
{
EnemyShipController ship = ((GameObject)Object.Instantiate(gameObject)).GetComponent <EnemyShipController>();
FlyController fly = ship.GetComponent <FlyController>();
PointGravityController pgrav = ship.GetComponent <PointGravityController>();
HullController hull = ship.GetComponent <HullController>();
Animator anim = ship.GetComponent <Animator>();
ship.PrefabName = name;
if (immobile)
{
ship.state = Modes.Appearing;
ship.GetComponent <Rigidbody2D>().isKinematic = hull.InitialShieldPower > 0;
ship.transform.position = orbit;
fly.enabled = false;
pgrav.enabled = false;
GetComponent <Collider2D>().enabled = false;
anim.SetTrigger("Appear");
}
else
{
ship.state = Modes.Flying;
fly.PrepareFly(orbit, planet);
ship.transform.position = position;
}
ship.Planet = planet;
return(ship);
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this.gameObject);
}
asteroidSpawnerController = this.GetComponent <AsteroidSpawnerController>();
planetController = GameObject.FindWithTag("Player").GetComponent <PlanetController>();
uiController = this.GetComponent <UiController>();
sceneController = this.GetComponent <SceneController>();
textPanelController = this.GetComponent <TextPanelController>();
lightController = this.GetComponent <LightController>();
controllers = new List <BaseController>(this.GetComponents <BaseController>())
{
planetController
};
InitAllControllers();
EnableAllControllers();
}
private void TakeOff(PlanetController planet)
{
hasLanded = false;
HostPlanet = null;
StopLoadingFuel();
OnPlayerTookOff?.Invoke(planet);
}
public void Init()
{
_planetController = GameModel.Get <PlanetController>();
_elements = GameConfig.Get <ElementConfig>().ElementsDictionary;
_universeConfig = GameConfig.Get <UniverseConfig>();
_debug = GameModel.Get <GameDebug>();
}
void SetPlanet(int id)
{
PlanetController pC = prefab.GetComponent <PlanetController>();
foreach (JSONNode mm in system)
{
if (mm["y"].AsInt == id)
{
planetName.text = mm["system_name"].ToString();
playerName.text = mm["nickname"].ToString();
planetAvatar.sprite = GetAvatar(mm["system_id"].AsInt);
pC.galaxy = mm["galaxy"].AsInt;
pC.x = mm["x"].AsInt;
pC.y = mm["y"].AsInt;
break;
}
else
{
planetName.text = "Пусто";
playerName.text = "Пусто";
planetAvatar.sprite = GetAvatar(mm["system_id"].AsInt);
pC.galaxy = mm["galaxy"].AsInt;
pC.x = mm["x"].AsInt;
pC.y = mm["y"].AsInt;
}
}
}
public virtual void Init(GameHandler handler, PlanetController planet, PlanetProblem.ProblemType type)
{
m_problemType = type;
m_gameHandler = handler;
m_planet = planet;
GetComponent <Grabbable>().m_planetController = planet;
}
void SetCurrentlyHoveredPlanet(PlanetController _planet, int _slot = -1)
{
if (_planet == m_currentlyHoveredPlanet && _slot == m_currentlyHoveredSlot)
{
return;
}
if (m_currentlyHoveredPlanet)
{
if (_planet != m_currentlyHoveredPlanet)
{
m_currentlyHoveredPlanet.planetMeshController.ClearHovers();
}
else if (_slot != m_currentlyHoveredSlot)
{
m_currentlyHoveredPlanet.planetMeshController.SetSlotHovered(m_currentlyHoveredSlot, false);
}
}
m_currentlyHoveredPlanet = _planet;
m_currentlyHoveredSlot = _slot;
if (m_currentlyHoveredPlanet)
{
m_currentlyHoveredPlanet.planetMeshController.SetSlotHovered(m_currentlyHoveredSlot, true);
}
}
private void FixedUpdate()
{
if (!weaponHolder.IsReadyToShoot)
{
return;
}
PlanetController bestCandidateToShoot = null;
var closestDot = Single.NegativeInfinity;
var forward = transform.right;
var thisPos = transform.position;
for (var i = otherPlanets.Count - 1; i >= 0; i--)
{
var otherPlanet = otherPlanets[i];
var delta = otherPlanet.transform.position - thisPos;
var otherPlanetDirection = delta.normalized;
var dot = Vector3.Dot(forward, otherPlanetDirection);
if (dot > closestDot)
{
closestDot = dot;
bestCandidateToShoot = otherPlanet;
}
}
if (closestDot > aimAccuracy)
{
weaponHolder.Shoot();
}
}
private void Awake()
{
this.InitializeMaterial();
parentPlanetController = GetComponentInParent <PlanetController>();
defaultLocalPos = transform.localPosition;
this.RegisterPlayerCallbacks();
}
public PlanetControllerTest()
{
planets = new List <Planet>
{
new Planet {
Id = 1, Name = "Planet 1", CreatedDate = DateTime.Now, LastUpdatedDate = DateTime.Now, Ordinal = 1
},
new Planet {
Id = 2, Name = "Planet 2", CreatedDate = DateTime.Now, LastUpdatedDate = DateTime.Now, Ordinal = 2
},
};
planetRepository = new Mock <IPlanetRepository>();
planetRepository
.Setup(p => p.GetPlanetsAsync())
.ReturnsAsync(planets);
profile = new Profile
{
Id = 1,
TypeId = 1,
TypeName = "Planet",
Content = "Content",
Introduction = "Introduction",
HasRings = false
};
profileRepository = new Mock <IProfileRepository>();
profileRepository
.Setup(p => p.GetProfileAsync(1, "Planet"))
.ReturnsAsync(profile);
controller = new PlanetController(planetRepository.Object, profileRepository.Object);
}
private void HandlePlayerLanding(PlanetController planetPlayerLandedOn)
{
if (planetPlayerLandedOn == HostPlanet)
{
CurrentAction = NpcActions.ActionFactory.GetAction(NpcActions.ActionType.MoveToShip);
}
}
private void HandlePlayerTakingOff(PlanetController planetPlayerTookOffFrom)
{
if (planetPlayerTookOffFrom == HostPlanet && CurrentAction.Type != NpcActions.ActionType.Wonder)
{
CurrentAction = NpcActions.ActionFactory.GetAction(NpcActions.ActionType.Wonder);
}
}
public void Init(bool onPlanet, PlanetController planetController, bool infestation = false)
{
m_planet = planetController;
m_onPlanet = onPlanet;
m_infest = infestation;
if (m_onPlanet)
{
m_angleOnPlanet = m_planet.GetPestSlot();
GetComponent <BoxCollider>().isTrigger = true;
RandomizeMe();
}
else
{
m_spriteRenderer.sprite = m_diveSprite;
m_spriteRenderer.color = m_color = Color.white;
m_direction = pestDirection(
m_planet.m_angle,
m_planet.m_speed,
new Vector2(transform.position.x, transform.position.y),
m_diveBombSpeed
);
transform.up = m_direction;
m_rigidBody.velocity = m_direction * m_diveBombSpeed;
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
// Uncomment to get some useful debugging info
//Debug.Log("PlayerGravityObjectController collided with " +
// collision.gameObject.name);
if (collision.gameObject.tag != planetTag)
{
return;
}
PlanetController pc =
collision.gameObject.GetComponent <PlanetController>();
Vector2 p2 = transform.position;
Vector2 p1 = collision.transform.position;
float angle =
Mathf.Atan2(p2.y - p1.y, p2.x - p1.x) * Mathf.Rad2Deg;
//Debug.Log("PlayerGravityObjectController's " +
// "collision angle is: " + angle);
GameObject pivot =
pc.PlaceEntity(transform.parent.gameObject, angle - 90);
RemoveForce();
transform.parent.SendMessage("OnPlanetCollision", pivot);
}
void Update()
{
if (!PlayerPrefs.HasKey(CheckpointName))
{
GameObject.Destroy(gameObject);
return;
}
try
{
StringReaderEx str = new StringReaderEx(PlayerPrefs.GetString(CheckpointName));
int enemiesCount = str.ReadLineInt();
Debug.Log("Load: enemies = " + enemiesCount);
for (int i = 0; i < enemiesCount; i++)
{
string prefabName = str.ReadLine();
string path = prefabName;
GameObject prefab = (GameObject)Resources.Load(path, typeof(GameObject));
Debug.Log("path: " + path + ", val=" + (prefab == null));
EnemyShipController ship = ((GameObject)GameObject.Instantiate(prefab)).GetComponent <EnemyShipController>();
ship.PrefabName = prefabName;
//ship.transform.position = str.ReadLineVector3();
//LoadObject(str,ship.gameObject);
ObjectSerializer.LoadObject(str, ship.gameObject);
//LoadClass<EnemyShipController>(str,ship);
//EnemyShipController enemy = GameObject.Instantiate()
}
PlanetController planet = GameObject.FindGameObjectWithTag("Planet").GetComponent <PlanetController>();
ObjectSerializer.LoadObject(str, planet.gameObject);
ObjectSerializer.LoadObject(str, planet.Gun.gameObject);
UIController ui = GameObject.Find("UICanvas").GetComponent <UIController>();;
ObjectSerializer.LoadComponent(str, ui.HpBar);
ObjectSerializer.LoadComponent(str, ui.Score);
ObjectSerializer.LoadComponent(str, planet.Multiplier.Indicator);
EnemyGeneratorController eg = GameObject.Find("EnemyGenerator").GetComponent <EnemyGeneratorController>();
ObjectSerializer.LoadComponent(str, eg);
StageController[] stages = eg.GetComponentsInChildren <StageController>(true);
foreach (StageController s in stages)
{
ObjectSerializer.LoadObject(str, s.gameObject);
}
}
catch (Exception e)
{
Debug.LogError("Exception while trying to load level: " + e.ToString());
}
GameObject.Destroy(gameObject);
}
void SelectPlanet(PlanetController planet)
{
Empire playerEmpire = EmpireManager.instance.GetPlayerEmpire();
playerEmpire.GetPlanetManager().SetSelectedPlanet(planet);
planetPanel.gameObject.SetActive(true);
planetPanel.SetPlanet(planet, playerEmpire.GetPlanetManager().OwnsPlanet(planet));
}
private void OnCollisionExit(Collision collision)
{
if (collision.gameObject.tag == "Landable")
{
PreviousPlanetHost = collision.gameObject.GetComponentInParent <PlanetController>();
TakeOff(PreviousPlanetHost);
}
}
void Awake()
{
planet = GetComponent <PlanetController>();
bonuses[5] = Bonus.Shield;
bonuses[10] = Bonus.Shield;
bonuses[15] = Bonus.Hp;
bonuses[20] = Bonus.Shield;
}
public void Init()
{
_compounds = GameConfig.Get <CompoundConfig>();
_unitController = GameModel.Get <UnitController>();
_planetController = GameModel.Get <PlanetController>();
_message = new CompoundControlMessage(0, CompoundControlAction.ADD, false);
_unitDefenseUpdateCommand = GameModel.Get <UnitDefenseUpdateCommand>();
}
protected virtual void OnPlayerUnassigned(Planet player)
{
if (ActivePlanet == player)
{
ActivePlanet = null;
ActiveController = null;
}
}
public void ShowLandingScreen(PlanetController planet, UnityAction dismissedCallback)
{
landingScreen.planet = planet;
landingScreen.gameObject.SetActive(true);
// LandingScreenController will clear this listener once it's dismissed.
landingScreen.dismissed.AddListener(dismissedCallback);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Crea tercer planeta con tamaño y posición aleatoria y le coloca el nombre con el número de planeta que es //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CreateNextPlanet()
{
GameObject newPlanet = Instantiate(planet, gameObject.transform);
PlanetController planetController = newPlanet.GetComponent <PlanetController>();
planetController.InitPlanet(++createdPlanets);
planets.Enqueue(newPlanet);
}
public override void Init(GameHandler handler, PlanetController planet, PlanetProblem.ProblemType type)
{
base.Init(handler, planet, type);
m_polyGen.GenerateMesh(m_radius, 15);
SetTexture(handler.m_textureGenerator.GenerateTexture(100, 100, 1));
//m_isActive = true;
//m_rigidBody.mass = m_mass;
}
public void setUniverseGenerator(Game game, FleetController fleetController, PlanetController planetController, ShipDesigner shipDesigner, TechStore techStore)
{
this.game.setGame(game);
this.fleetController = fleetController;
this.planetController = planetController;
this.shipDesigner = shipDesigner;
this.techStore = techStore;
}
public void Init()
{
_pay = GameModel.Get <CompoundPaymentService>();
_controller = GameModel.Get <UnitController>();
_planetController = GameModel.Get <PlanetController>();
_markedHexes = new List <HexModel>();
GameMessage.Listen <SkillDeactivateAllMessage>(OnSkillDeactivate);
}
public virtual void ClearPropsHolders(PlanetController planetController)
{
if (_clearPropsCoroutine != null)
{
StopCoroutine(_clearPropsCoroutine);
}
_clearPropsCoroutine = StartCoroutine(ClearPropsHoldersWithDelay(planetController));
}
public void ExitShip(PlanetController planet)
{
PlaySceneCanvasController.Instance.TravellersPanelController.RemoveEntryOfNpc(this);
HostPlanet = planet;
ShowNPC();
transform.rotation = Quaternion.identity;
transform.position = HostPlanet.Waypoints[UnityEngine.Random.Range(0, HostPlanet.Waypoints.Count)].position;
OnExitShip?.Invoke();
}
public void SetPlanet(PlanetController newPlanet, bool controllable)
{
planet = newPlanet;
playerControl = controllable;
PlanetData planetData = planet.GetPlanetData();
planetName.text = planetData.GetDisplayName();
}
// Use this for initialization
void Start()
{
if (planet == null)
{
planet = GameObject.FindGameObjectWithTag("Planet").GetComponent <PlanetController>();
}
planet.Asteroids++;
}
public virtual void InitializePropsHolders(PlanetController planetController)
{
if (_initializePropsCoroutine != null)
{
StopCoroutine(_initializePropsCoroutine);
}
_initializePropsCoroutine = StartCoroutine(InitializePropsHoldersWithDelay(planetController));
}
void Start ()
{
instance = this;
GeneratePlanets ();
}
