public void Start()
{
hub = GameObject.Find ("hub").GetComponent<Hub> ();
latice = hub.latice;
turnZones = new List<List<Quaternion>> ();
zoneController = hub.zoneController;
}
public void GenerateTransitionState_Tests()
{
//arrange
var controller = new ZoneController(1, "192.168.0.7");
var runner = new ZoneStateRunner(controller, new List <ZoneState>());
var now = Convert.ToDateTime("1/29/2015 12:00");
var startState = new ZoneState()
{
Brightness = 100,
Color = 0,
DayOfWeek = DayOfWeek.Thursday,
Time = new TimeSpan(0)
};
var endState = new ZoneState()
{
Brightness = 0,
Color = 100,
DayOfWeek = DayOfWeek.Friday,
Time = new TimeSpan(0)
};
//act
var transitionState = runner.GenerateTransitionState(startState, endState, now);
//assert
Assert.AreEqual(transitionState.Color, 50);
Assert.AreEqual(transitionState.Brightness, 50);
}
public void AssignZoneTest()
{
string zoneId = "533e1dd7-2a7f-18fb-b8ed-ed78c3f92c2b";
string subZoneId = "644e1dd7-2a7f-18fb-b8ed-ed78c3f92c2b";
Guid zoneGuid = Guid.Parse(zoneId);
Guid subZoneGuid = Guid.Parse(subZoneId);
UserDTO user = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(user);
var mockZoneService = new Mock <ZoneService>();
mockZoneService.Setup(zs => zs.AssignZone(subZoneGuid, zoneGuid)).Verifiable();
ZoneController zoneController = new ZoneController(mockUserService.Object, mockZoneService.Object, null);
zoneController.Request = createUserControllerRequest();
addTokenHeaderToRequest(zoneController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)zoneController.AssignZone(subZoneId, zoneId);
Assert.AreEqual(HttpStatusCode.OK, response.Response.StatusCode);
}
public void CreateZoneTest()
{
ZoneDTO zone = new ZoneDTO();
zone.MaxCapacity = 60;
zone.Name = "Zona 1";
UserDTO user = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(user);
var mockZoneService = new Mock <ZoneService>();
mockZoneService.Setup(zs => zs.AddZone(zone)).Verifiable();
ZoneController zoneController = new ZoneController(mockUserService.Object, mockZoneService.Object, null);
zoneController.Request = createUserControllerRequest();
addTokenHeaderToRequest(zoneController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)zoneController.Create(zone);
Assert.AreEqual(HttpStatusCode.Created, response.Response.StatusCode);
}
private void SetFirstTempValues(ZoneController zone)
{
foreach (var cell in zone.Cells)
{
if (cell.LeftCell != null && cell.LeftCell.Empty)
{
if (cell.tempValue < 0)
{
cell.LeftCell.tempValue = 0;
}
}
if (cell.RightCell != null && cell.RightCell.Empty)
{
if (cell.tempValue < 0)
{
cell.RightCell.tempValue = 0;
}
}
if (cell.TopCell != null && cell.TopCell.Empty)
{
if (cell.tempValue < 0)
{
cell.TopCell.tempValue = 0;
}
}
if (cell.BottomCell != null && cell.BottomCell.Empty)
{
if (cell.tempValue < 0)
{
cell.BottomCell.tempValue = 0;
}
}
}
}
private void SetZone(int zoneID, CellController cell, ZoneController zone, int currentSize)
{
cell.ZoneID = zoneID;
zone.Cells.Add(cell);
currentSize++;
if (currentSize > _maxZoneSize)
{
return;
}
if (cell.LeftCell != null && cell.LeftCell.ZoneID < 0 && !cell.LeftCell.Empty)
{
SetZone(zoneID, cell.LeftCell, zone, currentSize);
}
if (cell.RightCell != null && cell.RightCell.ZoneID < 0 && !cell.RightCell.Empty)
{
SetZone(zoneID, cell.RightCell, zone, currentSize);
}
if (cell.TopCell != null && cell.TopCell.ZoneID < 0 && !cell.TopCell.Empty)
{
SetZone(zoneID, cell.TopCell, zone, currentSize);
}
if (cell.BottomCell != null && cell.BottomCell.ZoneID < 0 && !cell.BottomCell.Empty)
{
SetZone(zoneID, cell.BottomCell, zone, currentSize);
}
}
/**
* @param z la zone ou le joueur
*/
public override void movePlayer(Zone z, ZoneController zc)
{
if (isFlying(z))
{
this.canFly = false; //Si le mouvement est distant on empeche d'utiliser une seconde fois le vol
}
base.movePlayer(z, zc);
}
public ElementInfo(ZoneController element, TypeBlock type, int number)
{
t = element.GetComponent <Transform>();
zc = element.GetComponent <ZoneController>();
obj = element.gameObject;
this.type = type;
this.number = number;
}
public void RegistrationZone(ZoneController zone)
{
current_zone = zone;
if (target != null)
{
target = null;
}
}
public ZoneControllerTest()
{
var zoneServiceMock = new Mock <IZoneService>();
zoneServiceMock.Setup(s => s.GetZones())
.Returns(ZoneServiceTestData.CreateZonesOne());
_zoneController = new ZoneController(zoneServiceMock.Object);
}
/// <summary>
/// Notifcation handler, called from the zone server, which delivers zone state changes
/// </summary>
/// <param name="sender">The zone controller, for which the state change appened.</param>
/// <param name="e">State change event arguments.</param>
private void OnZoneNotification(object sender, ZoneStateEventArgs e)
{
ZoneController zoneController = sender as ZoneController;
if (zoneController != null)
{
NotifySubscribers(zoneController.UniqueZoneId, e.ZoneState);
}
}
// Use this for initialization
void Start()
{
tarrainMask = LayerMask.GetMask("terrain");
zonePointMask = LayerMask.GetMask("zonePoint");
guiController = guiCanvas.GetComponent <GuiController>();
zoneController = zoneObject.GetComponent <ZoneController>();
DraggedPoint = null;
}
//обнуление всех параметров
protected void ResetUnitValue()
{
unit_way.Clear();
iMove = false;
unit_ui.gameObject.SetActive(true);
current_zone = null;
target = null;
GetComponent <CapsuleCollider>().enabled = true;
current_health = max_health;
}
private ZoneController _zoneController;//network event
public void Start()
{
_zoneController = new ZoneController(this);
int i = 1;
foreach (GameZone gameZone in GameManager.GameZones)
{
AddZone(gameZone, i);
i++;
}
}
// Use this for initialization
protected virtual void Start()
{
op = FindObjectOfType <ObjectPool> ();
zone = FindObjectOfType <ZoneController>();
GameObject previousPos = new GameObject("previous Pos");
prevPos = previousPos.transform;
m_currentMarker = Instantiate(m_navMarker, new Vector3(0, 4, 0), Quaternion.identity);
markerRenderers = m_currentMarker.GetComponentsInChildren <Renderer> ();
m_currentMarker.transform.position = troopController.currentSelectedUnit.transform.position;
}
public override JobHandle StartUpdateJob()
{
SetUpNativeArrays();
ZoneController zoneController = earth.GetZoneController();
job = AnimalUpdateJob.BeginJob(animalActions, updateAnimals, animalSpecies.GetActiveAnimalsCount(), animalSpecies.fullFood, animalSpecies.maxFood, animalSpecies.GetSightRange(), animalSpecies.GetEyeType(),
animalSpecies.GetEatRange(), animalSpecies.GetSmellRange(), animalSpecies.GetFoodIndex(), animalSpecies.eddibleFoodTypes,
animalSpecies.predatorFoodTypes, zoneController.allAnimals, zoneController.allPlants,
zoneController.zones, zoneController.neiboringZones, zoneController.animalsInZones, zoneController.plantsInZones,
zoneController.organismsByFoodTypeInZones);
return(job);
}
public void Start()
{
hub = GameObject.Find ("hub").GetComponent<Hub> ();
latice = hub.latice;
turnZones = new List<List<Quaternion>> ();
zoneController = hub.zoneController;
if(target_retical!=null){
GameObject reticle = (GameObject)Instantiate(target_retical,transform.position,transform.rotation);
reticle.transform.parent=this.transform;
}
}
private void ZoneAction()
{
if (c_positionData.u_zone == uint.MaxValue)
{
return;
}
if (ZoneController.GetZoneType(c_positionData.u_zone) == ZoneType.FINISH_LINE)
{
Message playerFinished = new Message(c_entityData.u_entityID);
MessageServer.SendMessage(MessageID.PLAYER_FINISHED, playerFinished);
}
}
public void SetUpEarth(int size, float simulationSpeed)
{
this.simulationDeltaTime = simulationSpeed / 10;
this.size = size;
transform.localScale = new Vector3(size, size, size);
SetupFoodTypeIndex();
SetupSpeciesFoodType();
frameManager = GetComponent <FrameManager>();
zoneController = GetComponent <ZoneController>();
zoneController.SetupZoneController(this);
zoneController.SpawnZones(size, SimulationScript.Instance.numberOfZones, SimulationScript.Instance.maxNeiboringZones, SpeciesManager.Instance.GetAllStartingPlantsAndSeeds() * 5, SpeciesManager.Instance.GetAllStartingAnimals() * 5, SimulationScript.Instance.zoneSetup);
earthState = new EarthState();
}
private void CheckZone(ZoneController zone, List <int> ids)
{
ids.Add(zone.ZoneID);
foreach (var connectedZone in zone.Neighbors)
{
if (ids.Contains(connectedZone.ZoneID))
{
continue;
}
CheckZone(connectedZone, ids);
}
}
private void Awake()
{
rb2d = GetComponent <Rigidbody>();
transform = GetComponent <Transform>();
inputController = FindObjectOfType <InputController>();
zoneController = FindObjectOfType <ZoneController>();
landerCollider = GetComponent <Collider>();
audioManager = AudioManager.instance;
}
private IEnumerator CreateZones()
{
_zones = new List <ZoneController>();
int idCounter = 0;
ZoneController zone = new ZoneController();
zone.ZoneID = idCounter;
_zones.Add(zone);
for (int i = _worldSize / 2 - _homeSize / 2; i <= _worldSize / 2 + _homeSize / 2; i++)
{
for (int j = _worldSize / 2 - _homeSize / 2; j <= _worldSize / 2 + _homeSize / 2; j++)
{
_cellsArr[i, j].ZoneID = idCounter;
_cellsArr[i, j].Empty = false;
zone.Cells.Add(_cellsArr[i, j]);
}
}
idCounter++;
for (int x = 0; x < _worldSize; x++)
{
for (int y = 0; y < _worldSize; y++)
{
CellController cell = _cellsArr[x, y];
if (cell == null || cell.Empty || cell.ZoneID >= 0)
{
continue;
}
zone = new ZoneController();
zone.ZoneID = idCounter;
SetZone(idCounter, cell, zone, 0);
zone.SetColor();
_zones.Add(zone);
idCounter++;
yield return(new WaitForEndOfFrame());
}
}
}
private void CheckForZone()
{
float distance = c_playerData.f_currentForwardRaycastDistance + (c_playerData.f_currentSpeed * Time.fixedDeltaTime);
if (Physics.Raycast(c_playerData.v_currentPosition, c_playerData.q_currentRotation * Vector3.forward, out forwardHit, distance, ZoneCollisionMask))
{
// notify that we have collided with a zone, grab the zone's ID and send corresponding message
ZoneController controller = GameMasterController.LookupZoneController(forwardHit.transform);
if (controller != null && c_positionData.u_zone != controller.u_zoneId)
{
c_positionData.u_zone = controller.u_zoneId;
ZoneAction();
}
}
}
public static bool AddZoneToList(ref Transform transformIn, ZoneController controllerIn)
{
if (l_zones == null)
{
l_zones = new Dictionary <Transform, ZoneController>();
}
if (l_zones.ContainsKey(transformIn))
{
return(false);
}
l_zones.Add(transformIn, controllerIn);
return(true);
}
private void Awake()
{
ValidateSerialisedFields();
zoneController = GameObject.Find(ZoneObjectName).GetComponentInChildren <ZoneController>();
if (zoneController.DistanceOffSet.x > 0)
{
worldSize = zoneController.DistanceOffSet * zoneController.CurrentRadius * 7;
}
else
{
worldSize = new Vector2(zoneController.CurrentRadius * 7, zoneController.CurrentRadius * 7);
}
timeLastSpawn = 0;
}
private void Awake()
{
deckController = deck.GetComponent <DeckController>();
handsController = hands.GetComponent <HandsController>();
meleeZoneController = transform.DeepFind("MeleeZone").gameObject.GetComponent <ZoneController>();
meleeZoneController.pc = this;
rangedZoneController = transform.DeepFind("RangedZone").gameObject.GetComponent <ZoneController>();
rangedZoneController.pc = this;
siegeZoneController = transform.DeepFind("SiegeZone").gameObject.GetComponent <ZoneController>();
siegeZoneController.pc = this;
/*
* if(deckController == null)
* if(handsController == null)
*/
}
public void PlayCard(GameObject cardObj, ZoneController zc)
{
if (cardObj.GetComponent <DragHandler>().pc.isAi == TurnSystem.Instance.isYourTurn)
{
return; //can not play card in oppo's turn
}
if (zc.pc.isAi == TurnSystem.Instance.isYourTurn)
{
return; //playing card in enemy's zone is forbided except spy(not implement yet)
}
DragHandler dragHandler = cardObj.GetComponent <DragHandler>();
dragHandler.setNewParent();
cardObj.GetComponent <MonsterCardController>().PlayCard();
zc.UpdatePower();
}
void Awake()
{
audioManager = AudioManager.instance;
playerInfo = FindObjectOfType <PlayerInfo>();
sceneController = FindObjectOfType <SceneController>();
shipControllers = FindObjectsOfType <ShipController>();
zoneController = FindObjectOfType <ZoneController>();
cameraController = FindObjectOfType <CameraController>();
inputController = FindObjectOfType <InputController>();
uiController = FindObjectOfType <UIController>();
}
public void CreateZone()
{
switch (Links.Interface.ZoneTypeSelect.value)
{
case 0:
ZoneController.CreateZone(_ZoneStartPoint.transform.position, _ZoneEndPoint.transform.position, 1, _StorageType);
break;
case 1:
ZoneController.CreateZone(_ZoneStartPoint.transform.position, _ZoneEndPoint.transform.position, 4, _StorageType);
break;
case 2:
ZoneController.CreateZone(_ZoneStartPoint.transform.position, _ZoneEndPoint.transform.position, 5, _StorageType);
break;
}
CancelZoneCreation();
}
public void SetZone(ZoneController zone)
{
if (_zone != null)
{
_zone.Invaded -= OnPlayerInvaded;
}
_zone = zone;
if (_zone != null)
{
if (_zone.Invader != null)
{
OnPlayerInvaded(_zone, _zone.Invader);
}
_zone.Invaded += OnPlayerInvaded;
}
}
void Start()
{
hub = GameObject.Find("hub").GetComponent<Hub>();
latice = hub.latice;
Looper = GetComponent<Looper>();
zoneController = hub.player.GetComponent<ZoneController>();
startZone = hub.player.GetComponent<Looper>().LoopCounter;
GameObject Projection = new GameObject ();
Clone_Props = new CloneProperties ();
Projection.AddComponent <MeshRenderer> ();
Projection.renderer.material = renderer.material;
Mesh mesh = GetComponent<MeshFilter> ().mesh;
Projection.AddComponent<MeshFilter> ().mesh = mesh;
renderer.enabled=false;;
Projection.transform.localScale = transform.localScale;
Projection.name = this.gameObject.name + "_Projection";
Clone_Props.Original = transform;
Clone_Props.self = Projection;
}
public void AddZone() {
currentZone.SetZone ();
zones.Add (currentZone);
currentZone = null;
}
public void CreateZone(Vector3 pos, int width, int height) {
var z = new ZoneController (ZonesParentGO, pos, width, height);
currentZone = z;
}
private void OnEnable()
{
controller = (ZoneController)target;
lastTool = Tools.current;
}
public void OnEndDrag(PointerEventData eventData)
{
transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, 100);
Island modele = player.GetModele();
if (Camera.main != null && modele.isMovable(player))
{
Vector3 worldPosition1;
worldPosition1 = Camera.main.ScreenToWorldPoint(Input.mousePosition);
worldPosition1.z = -1 * worldPosition1.z;
RaycastHit2D hit = Physics2D.Raycast(transform.position, -Vector2.up);
if (hit.collider != null)
{
print(hit.collider.name);
if (hit.collider.name == "ZoneNormal(Clone)(Clone)")
{
ZoneController zc = hit.collider.GetComponent <ZoneController>();
Zone zone = zc.GetZone();
if (modele.getRoundOf().Equals(player))
{
List <Zone> listZones = player.zonesSafeToMove();
if (listZones.Contains(zone) && player.canAct() && zone != player.getZone())
{
float tileSize = GridController.tileSize;
/*transform.localPosition = zc.LocalPosPawn();
* initPos = transform.localPosition;*/
player.movePlayer(zone, zc);
player.addAction();
}
else
{
print("Mouvement interdit");
transform.localPosition = initPos;
}
}
else
{
Player navigateur = modele.getRoundOf();
List <Zone> listZones = Navigateur.zonesReachableNavigateur(modele, player.getZone().getPosition());
if (listZones.Contains(zone) && navigateur.canAct() && zone != player.getZone())
{
player.movePlayer(zone, zc); // on bouge l'autre joueur
navigateur.addAction(); // on incremente l'action du navigateur
}
else
{
print("Mouvement interdit");
}
}
}
else
{
transform.localPosition = initPos;
}
}
else
{
transform.localPosition = initPos;
}
}
transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, -1);
}
