void FindVisibleTargets()
{
targetsInView.Clear();
Collider2D[] targetsInViewRadius = Physics2D.OverlapCircleAll((new Vector2(transform.position.x, transform.position.y)), viewRadius, playerMask);
ComputerController npc = GetComponent <ComputerController> ();
for (int i = 0; i < targetsInViewRadius.Length; i++)
{
Transform target = targetsInViewRadius [i].transform;
Vector3 directionToTarget = (target.position - transform.position);
if (Vector2.Angle(npc.getDirection2D(), directionToTarget) < viewAngle / 2)
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, npc.getDirection2D());
if (hit.collider != null)
{
targetsInView.Add(target);
if (target.gameObject.CompareTag("useable") && target.gameObject.GetComponent <SpriteRenderer> ().enabled == true)
{
StartCoroutine("UseableDelay", 10f);
}
else if (target.gameObject.CompareTag("useable") && target.gameObject.GetComponent <SpriteRenderer> ().enabled == false)
{
;
}
else
{
//ifDetected.text = "DETECTED! Restarting...";
isDetected = true;
LoseScreen.SetActive(true);
PlayerData.Instance.coins = 0;
}
}
}
}
}
private void Awake()
{
plaerScore.text = "0";
computerScore.text = "0";
playerButton.interactable = computerButton.interactable = false;
gridManagar = grid.GetComponent <GridManagar>();
gridManagar.BuildGrid(this);
computer = new ComputerController();
sceneManager = GetComponent <SceneManager>();
if (gameLevel == GameLevel.Hard)
{
computerTurn = true;
ComputerMove();
computerButtonText.text = "X";
playerButtonText.text = "O";
}
else
{
computerButtonText.text = "O";
playerButtonText.text = "X";
}
}
public void Add_ValidModelLicenseTypeWithResultPost_ReturnsRedirect()
{
var computerFake = new Computer
{
LicenseType = "WinXP",
};
var computerDataService = new Mock <IDataService <Computer> >();
computerDataService.Setup(c => c.Insert(It.IsAny <Computer>(), It.IsAny <Guid>())).Verifiable();
var windowsLicenseDataServiceMock = new Mock <IDataService <WindowsLicense> >();
windowsLicenseDataServiceMock.Setup(w => w.SelectOne(It.IsAny <Expression <Func <WindowsLicense, bool> > >()))
.Returns(new WindowsLicense
{
Id = "123456",
LicenseType = computerFake.LicenseType,
});
var controller = new ComputerController(computerDataService.Object,
new Mock <IFormsAuthenticationService>().Object,
windowsLicenseDataServiceMock.Object,
new Mock <IDataService <Volunteer> >().Object);
ActionResult result = controller.Add(computerFake);
Assert.IsInstanceOf <RedirectToRouteResult>(result);
computerDataService.VerifyAll();
}
public void Manifest_ResultsView()
{
var fakeComputer = new Computer
{
Id = Guid.NewGuid(),
ManifestHtml =
@"
<html>
<head><title>LB0124</title></head>
<body>
<p>Hello World LB0124</p>
</body>
</html>"
};
var computerDataService = new Mock <IDataService <Computer> >();
computerDataService.Setup(c => c.SelectOne(It.IsAny <Expression <Func <Computer, bool> > >()))
.Returns(fakeComputer);
var controller = new ComputerController(computerDataService.Object,
new Mock <IFormsAuthenticationService>().Object,
new Mock <IDataService <WindowsLicense> >().Object,
new Mock <IDataService <Volunteer> >().Object);
ActionResult result = controller.Manifest(fakeComputer.Id);
}
public void StopUseComputer(GameObject computer)
{
stateController.CanMove(true);
stateController.SetActiveComputer(computer, false);
cameraController.SetCamera(computerController.computerCamera, false);
computerController.StopUse();
computerController = null;
}
IEnumerator UseableDelay(float delay)
{
ComputerController npc = GetComponent <ComputerController> ();
npc.speed = 0;
yield return(new WaitForSeconds(delay));
npc.speed = 1.5f;
}
public ComputerApplication(string _appName)
{
pc = ComputerController.instance;
appName = _appName;
isEnabled = false;
showOnTaskBar = true;
showInStart = true;
windowWidth = 800;
windowHeight = 900;
}
private void Start()
{
if (Player2 != null)
{
computer = Player2.GetComponent <ComputerController>();
player = Player2.GetComponent <PlayerController>();
}
UpdateText();
}
public GameController()
{
_mazeController = new MazeController();
_consoleController = new ConsoleController();
_computerController = new ComputerController();
_consoleBoard = new ConsoleBoard(new Square()
{
Width = 20,
Height = 20
});
}
private void OnTriggerEnter2D(Collider2D collisionObject)
{
if (collisionObject.tag == "Top Wall" || collisionObject.tag == "Botom Wall")
{
RevertYForce();
sound.Play();
}
if (collisionObject.tag == "StickCorner")
{
// Speed up the ball due to collision with small surface
MinimalForce *= SpeedIncrease;
sound.Play();
RevertXForce();
}
if (collisionObject.tag == "StickMiddle")
{
// Slow down the ball due to collision with big surface but keeping the initial speed a a constant
if (MinimalForce > initMinForce)
{
MinimalForce /= SpeedIncrease;
}
if (MinimalForce < initMinForce)
{
MinimalForce = initMinForce;
}
sound.Play();
RevertXForce();
}
// Acts like natural hit on a wall
if (collisionObject.tag.Contains("Side Wall"))
{
Ball.position = Vector2.zero;
if (collisionObject.name.Contains("Right"))
{
PlayerController.PlayerScores++;
PlayerController.PlayScoreSound();
}
else
{
ComputerController.ComputerScores++;
ComputerController.PlayScoreSound();
}
NewGame();
return;
}
}
private void addVirtualPC(object sender, RoutedEventArgs e)
{
AddVirtualComputerWindow window = new AddVirtualComputerWindow();
window.ShowDialog();
if (window.DialogResult == false)
{
computer = new ComputerController(new ContextVirtualPC());
virtualName.ItemsSource = computer.GetListComputers();
virtualName.SelectedItem = Singleton.ComputerName;
}
}
private void gameData_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
Singleton.GamePosition = gameData.Items.IndexOf(gameData.SelectedCells[0].Item) + 1;
GameWindow window = new GameWindow();
window.ShowDialog();
if (window.DialogResult == false)
{
computer = new ComputerController(new ContextPhysicalPC());
pcName.ItemsSource = computer.GetListComputers();
pcName.SelectedItem = Singleton.ComputerName;
}
}
public void Edit_InvalidModel_ReturnsView()
{
var controller = new ComputerController(new Mock <IDataService <Computer> >().Object,
new Mock <IFormsAuthenticationService>().Object,
new Mock <IDataService <WindowsLicense> >().Object,
new Mock <IDataService <Volunteer> >().Object);
controller.ModelState.AddModelError("test", "error");
ActionResult result = controller.Edit(new Computer());
Assert.IsInstanceOf <ViewResult>(result);
}
public void Add_ValidModelWithLicenseTypeNoResultsPost_ReturnsView()
{
var controller = new ComputerController(new Mock <IDataService <Computer> >().Object,
new Mock <IFormsAuthenticationService>().Object,
new Mock <IDataService <WindowsLicense> >().Object,
new Mock <IDataService <Volunteer> >().Object);
ActionResult result = controller.Add(new Computer
{
LicenseType = "WinXP",
});
Assert.IsInstanceOf <ViewResult>(result);
}
public void UseComputer(GameObject computer)
{
computerController = computer.GetComponent <ComputerController>();
if (!computerController.inZone)
{
return;
}
stateController.CanMove(false);
stateController.SetActiveComputer(computer, true);
cameraController.SetCamera(computerController.computerCamera, true);
computerController.Use();
}
protected void AddToCart(object sender, EventArgs e)
{
LoadComputerParts();
var laptop = new Computer();
laptop.ComputerType = "laptop";
laptop.Id = ComputerController.GetComputerCount() + 1;
laptop.UserId = UserController.GetUserIdByName(Context.User.Identity.Name);
laptop.UserName = Context.User.Identity.Name;
laptop.Part1 = _screenSizes
.Where(s => s.Price == int.Parse(ScreenSize.SelectedValue))
.Select(s => s.PartName)
.First();
laptop.Part2 = _processors
.Where(s => s.Price == int.Parse(Processor.SelectedValue))
.Select(s => s.PartName)
.First();
laptop.Part3 = _rams
.Where(s => s.Price == int.Parse(RamSize.SelectedValue))
.Select(s => s.PartName)
.First();
laptop.Part4 = _ssds
.Where(s => s.Price == int.Parse(SsdCapacity.SelectedValue))
.Select(s => s.PartName)
.First();
laptop.Part5 = _osi
.Where(s => s.Price == int.Parse(OperatingSystem.SelectedValue))
.Select(s => s.PartName)
.First();
ComputerController.AddComputer(laptop);
var newCartItem = new CartItem();
newCartItem.UserName = Context.User.Identity.Name;
newCartItem.TypeName = "laptop";
newCartItem.ComputerId = laptop.Id;
newCartItem.Price = CalculateTotal();
CartController.AddToCart(newCartItem);
Response.Redirect("~/Cart.aspx", true);
}
public void Add_ReturnsView()
{
var controller = new ComputerController(new Mock <IDataService <Computer> >().Object,
new Mock <IFormsAuthenticationService>().Object,
new Mock <IDataService <WindowsLicense> >().Object,
new Mock <IDataService <Volunteer> >().Object);
ActionResult result = controller.Add();
Assert.IsInstanceOf <ViewResult>(result);
var view = (ViewResult)result;
Assert.IsInstanceOf <Computer>(view.Model);
}
public void Add_ValidModelNoLicenseTypePost_ReturnsRedirect()
{
var computerDataService = new Mock <IDataService <Computer> >();
computerDataService.Setup(c => c.Insert(It.IsAny <Computer>(), It.IsAny <Guid>())).Verifiable();
var controller = new ComputerController(computerDataService.Object,
new Mock <IFormsAuthenticationService>().Object,
new Mock <IDataService <WindowsLicense> >().Object,
new Mock <IDataService <Volunteer> >().Object);
ActionResult result = controller.Add(new Computer());
Assert.IsInstanceOf <RedirectToRouteResult>(result);
computerDataService.VerifyAll();
}
public void UpdateState()
{
player = state.Player;
computer = state.Computer;
ShowPlayerView();
ShowComputerView();
player.UpdateMissed(dgvPlayer);
computer.UpdateMissed(dgvComputer);
score = state.Score;
Turn = state.Turn;
btnRandomize.Visible = false;
btnStart.Text = "Resume";
dgvPlayer.Enabled = false;
MuteClicked = state.Mute;
CheckIcon();
}
public Game()
{
DoubleBuffered = true;
Turn = true;
InitializeComponent();
player = new PlayerController();
isFinished = false;
score = 0;
computer = new ComputerController();
dgvPlayer.DoubleBuffered(true);
dgvComputer.DoubleBuffered(true);
GameStarted = false;
MuteClicked = false;
ShowPlayerView();
ShowComputerView();
this.Cursor = LoadCursorFromResource();
}
public ServerResponseInformation GetComputerComponent
(ClientCommandInformation clientCommand)
{
AuthorizeController authorizeController = (AuthorizeController)_serviceProvider
.GetService(typeof(AuthorizeController));
var resAuthorize = authorizeController.Authorize(clientCommand.ClientLogin);
if (resAuthorize != null)
{
return(resAuthorize);
}
ComputerHardwareInformationDTO chInformation = JsonConvert
.DeserializeObject <ComputerHardwareInformationDTO>(clientCommand.SerializedData);
ComputerController computerController = (ComputerController)_serviceProvider
.GetService(typeof(ComputerController));
return(computerController.RecieveComputerHardwareInformation(chInformation, clientCommand.ClientLogin));
}
static void Main(string[] args)
{
Console.WriteLine("Собран ПК:");
ComputerController computer = new ComputerController("Игровой", 50000);
Console.WriteLine(computer.printFullInfo());
PartController pc = new PartController();
foreach (var part in pc.getAllPartsOfOneType("gpu"))
{
Console.WriteLine(part.Name.ToString());
}
Console.ReadLine();
}
public Vector3 dFromAngle(float angle, bool isGlobal)
{
if (!isGlobal)
{
ComputerController player = GetComponent <ComputerController> ();
if (player.getDirection() == Vector3.right)
{
angle += 90;
}
else if (player.getDirection() == Vector3.left)
{
angle += -90;
}
else if (player.getDirection() == Vector3.down)
{
angle += 180;
}
}
return(new Vector3(Mathf.Sin(angle * Mathf.Deg2Rad), Mathf.Cos(angle * Mathf.Deg2Rad), -1));
}
public void Edit_ReturnsView()
{
var computerDataServiceMock = new Mock <IDataService <Computer> >();
computerDataServiceMock.Setup(c => c.SelectOne(It.IsAny <Expression <Func <Computer, bool> > >()))
.Returns(new Computer());
var controller = new ComputerController(computerDataServiceMock.Object,
new Mock <IFormsAuthenticationService>().Object,
new Mock <IDataService <WindowsLicense> >().Object,
new Mock <IDataService <Volunteer> >().Object);
ActionResult result = controller.Edit(Guid.NewGuid());
Assert.IsInstanceOf <ViewResult>(result);
var view = (ViewResult)result;
Assert.IsInstanceOf <Computer>(view.Model);
}
public void Edit_ValidModel_ReturnsRedirect()
{
var computerFake = new Computer
{
WindowsLicense = "1234",
};
var computerDataServiceMock = new Mock <IDataService <Computer> >();
computerDataServiceMock.Setup(c => c.Update(It.IsAny <Computer>())).Verifiable();
computerDataServiceMock.Setup(c => c.SelectOne(It.IsAny <Expression <Func <Computer, bool> > >()))
.Returns(computerFake);
var formsAuthenticationServiceMock = new Mock <IFormsAuthenticationService>();
formsAuthenticationServiceMock.Setup(f => f.GetVolunteerID(null))
.Returns(Guid.NewGuid());
var volunterDataServiceMock = new Mock <IDataService <Volunteer> >();
volunterDataServiceMock.Setup(v => v.SelectOne(It.IsAny <Expression <Func <Volunteer, bool> > >()))
.Returns(new Volunteer());
var windowsLicenseFake = new WindowsLicense();
var windowsLicenseDataServiceMock = new Mock <IDataService <WindowsLicense> >();
windowsLicenseDataServiceMock.Setup(w => w.SelectOne(It.IsAny <Expression <Func <WindowsLicense, bool> > >()))
.Returns(windowsLicenseFake);
windowsLicenseDataServiceMock.Setup(w => w.Update(windowsLicenseFake)).Verifiable();
var controller = new ComputerController(computerDataServiceMock.Object,
formsAuthenticationServiceMock.Object,
windowsLicenseDataServiceMock.Object,
volunterDataServiceMock.Object);
ActionResult result = controller.Edit(computerFake);
Assert.IsInstanceOf <RedirectToRouteResult>(result);
computerDataServiceMock.VerifyAll();
windowsLicenseDataServiceMock.VerifyAll();
}
private void Initialize()
{
Transform canvas = FindObjectOfType <Canvas>().transform;
Pile pile = new Pile();
PileView pileView = Instantiate(Resources.Load <PileView>("Prefabs/Pile"), canvas);
pileController = new PileController(pile, pileView);
Player player = new Player();
PlayerView playerView = Instantiate(Resources.Load <PlayerView>("Prefabs/Player"), canvas);
playerController = new PlayerController(player, playerView, pileController);
Computer computer = new Computer(pile);
ComputerView computerView = Instantiate(Resources.Load <ComputerView>("Prefabs/Computer"), canvas);
computerController = new ComputerController(computer, computerView, pileController);
menuManager = Instantiate(Resources.Load <MenuManager>("Prefabs/Menu"), canvas);
}
private void addVirtualPC(object sender, RoutedEventArgs e)
{
ComputerController computer = new ComputerController(new ContextVirtualPC());
if (namePC.Text != null && cpuName.SelectedItem != null && gpuName.SelectedItem != null && ramFrequency.SelectedItem != null && hardCode.SelectedItem != null && osVersion.SelectedItem != null)
{
computer.SetComputer(namePC.Text, cpuName.SelectedItem.ToString(), gpuName.SelectedItem.ToString(),
ramType.SelectedItem.ToString() + ", " + ramCapacity.SelectedItem.ToString() + " GB, " + ramFrequency.SelectedItem.ToString() + " MHz",
hardCode.SelectedItem.ToString(), osName.SelectedItem.ToString(), osVersion.SelectedItem.ToString());
MessageBox.Show("Компьютер успешно добавлен", "Выполнено", MessageBoxButton.OK, MessageBoxImage.Asterisk);
Close();
}
else
{
MessageBoxResult result = MessageBox.Show("Ошибка при добавлении компьютера" +
"\nПроверьте заполненность полей", "Ошибка",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
public void SendGValuePulse()
{
hasBeenPulsedG = true;
ComputerController cc;
try
{ cc = GameObject.FindGameObjectWithTag("Player").GetComponent <ComputerController>(); }
catch {
cc = new ComputerController();
print("Error: Computer not found");
Destroy(this);
}
for (int i = 0; i < connectedBlocks.Count; i++)
{
if (cc.GetClosedList().Contains(connectedBlocks[i]) && !connectedBlocks[i].GetPulseGStatus())
{
connectedBlocks[i].SetGValue(stepsTakenG + 1);
connectedBlocks[i].SetPulsedGStatusTrue();
gc.AddGValueCalcOrder(connectedBlocks[i]);
}
}
}
private void importVirtualPC(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
computer = new ComputerController(new ContextVirtualPC());
openFileDialog.Filter = "XML files (*.xml)|*.xml";
if (openFileDialog.ShowDialog() == true)
{
string path = openFileDialog.FileName;
try
{
controller.SetData(path);
virtualName.ItemsSource = computer.GetListComputers();
virtualName.SelectedItem = Singleton.ComputerName;
}
catch
{
MessageBox.Show("Не удалось импортировать конфигурацию" +
"\nПроверьте качество импортируемого файла", "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
public void interact()
{
RaycastHit hitInfo;
Vector3 dept = transform.TransformDirection(new Vector3(0, 0, 1));
if (Physics.Raycast(transform.position, dept, out hitInfo, 100, 1 << 9))
{
ComputerController script = hitInfo.collider.gameObject.GetComponent <ComputerController>();
if (script != null)
{
hitInfo.collider.gameObject.GetComponent <ComputerController>().interact();
movable = false;
}
else
{
ComputerControllerRobot scriptRobot = hitInfo.collider.gameObject.GetComponent <ComputerControllerRobot>();
if (scriptRobot != null)
{
hitInfo.collider.gameObject.GetComponent <ComputerControllerRobot>().interact();
movable = false;
}
}
}
}
