Пример #1
0
        public static HashDevice GetDeviceFromSerializedData(SerializedHashDevice serializedDevice)
        {
            var device = new HashDevice();

            device.DeviceName = serializedDevice.DeviceName;
            device.Condition  = serializedDevice.Condition;
            device.IpAddress  = serializedDevice.IpAddress;

            device.AllPrograms = ProgramUtil.GetAllProgramsFromSerializedData(serializedDevice.Programs);
            device.AllUsers    = SList.Create <HashUser>(serializedDevice.Users.Length);

            for (int i = 0; i < serializedDevice.Users.Length; i++)
            {
                var user = GetUserFromSerializedData(serializedDevice.Users[i]);
                SList.Add(device.AllUsers, user);
            }

            var defaultUser = new HashUser();

            defaultUser.Username = DEFAULT_USER_NAME;
            defaultUser.Password = DEFAULT_PASSWORD;

            SList.Add(device.AllUsers, defaultUser);

            device.FileSystem = FileSystem.GetFileSystemFromSerializedData(serializedDevice.FileSystem);

            return(device);
        }
Пример #2
0
        /// <summary>
        /// Initialized the game.
        /// </summary>
        public void InitializeGame()
        {
#if DEB
            if (GUIReferences.InputListener == null)
            {
                DebugUtil.Error("INPUT LISTENER IS NULL. PLEASE BAKE THE GAME HOLDER!");
            }
            if (GUIReferences.TerminalComponent == null)
            {
                DebugUtil.Error("TERMINAL COMPONENT IS NULL. PLEASE BAKE THE GAME HOLDER!");
            }
#endif

            Constants.Colors           = Colors;
            DataHolder.DebugCondition  = DebugCondition;
            DataHolder.GUIReferences   = GUIReferences;
            DataHolder.DreamReferences = DreamReferences;

            DataHolder.GUIReferences.TerminalComponent.Initialize();
            StoryUtil.Init();
            LoopUtil.Init();
            WindowUtil.Initialize();
            DataUtil.LoadData();
            ProgramUtil.SetupPrograms();
            GUIUtil.SetCursorToDefault();

            TerminalUtil.HideTerminal();
            AnnouncementUtil.HideAnnouncement();

            DreamUtil.ExecuteDreamOne();
        }
Пример #3
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                var latitudeParam  = CommandLineUtil.FindArgumentByName(options.ParsedArguments, LatitudeParameterName);
                var longitudeParam = CommandLineUtil.FindArgumentByName(options.ParsedArguments, LongitudeParameterName);

                var latitude  = latitudeParam.Value;
                var longitude = longitudeParam.Value;

                float fLatitude;
                float fLongitude;
                if (ValidateCoords(latitude, longitude, out fLatitude, out fLongitude))
                {
                    float imageWidth  = AditionalData.MapTexture.width;
                    float imageHeight = AditionalData.MapTexture.height;

                    var markerPositon = new Vector2(fLatitude, fLongitude);

                    var dimentions = AditionalData.MapDimentions;
                    if (dimentions.Contains(markerPositon))
                    {
                        string title       = string.Format("Map for lat: {0:F3} / lon: {1:F3}", fLatitude, fLongitude);
                        var    imageWindow = WindowUtil.CreateImageWindow(AditionalData.MapTexture, title);

                        var holder         = imageWindow.MainWidget;
                        var markerInstance = NGUITools.AddChild(holder.gameObject, AditionalData.MarkerGameObject);

                        markerInstance.transform.localPosition = GetMarkerPosition(AditionalData.MapTexture, dimentions, markerPositon);
                    }
                    else
                    {
                        var fromDimention = string.Format("[lat {0} / lon {1}]", dimentions.xMin, dimentions.yMin);
                        var toDimention   = string.Format("[lat {0} / lon {1}]", dimentions.xMax, dimentions.yMax);
                        var msg           = "The given positon lies outside the available map. The map data encloses goes from {0} to {1}";
                        msg = string.Format(msg, fromDimention, toDimention);
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                    }
                }
                else
                {
                    var msg = "Invalid coordinates. Please supply latitude and longitude as decimal numers.\nEx: lat 25.6939 log 91.9057";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
            }
            else
            {
                var msg = "Error. Please supply a valid latitude and longitude";
                msg = TextUtil.Error(msg);
                TerminalUtil.ShowText(msg);
            }
        }
Пример #4
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            var args = options.ParsedArguments;

            if (CommandLineUtil.ValidateArguments(args, Validations))
            {
                var hintArg = CommandLineUtil.FindArgumentByName(args, HintArgName);
                Pair <string, string> deviceArg;
                Pair <string, string> fileArg;

                var deviceExists = CommandLineUtil.TryGetArgumentByName(args, DeviceArgName, out deviceArg);
                var fileExists   = CommandLineUtil.TryGetArgumentByName(args, FileArgName, out fileArg);
                if (deviceExists && fileExists)
                {
                    var msg = "You need to supply either a file or a device, never both.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
                else
                {
                    if (deviceExists)
                    {
                        Pair <string, string> usernameArg;
                        var usernameExists = CommandLineUtil.TryGetArgumentByName(args, UsernameArgName, out usernameArg);
                        if (usernameExists)
                        {
                            ExecuteOnDevice(deviceArg, usernameArg, hintArg);
                        }
                        else
                        {
                            var msg = "If you are targeting a device, please supply a username for whose password should be discovered.";
                            msg = TextUtil.Error(msg);
                            TerminalUtil.ShowText(msg);
                        }
                    }
                    else if (fileExists)
                    {
                        ExecuteOnFile(fileArg, hintArg);
                    }
                }
            }
            else
            {
                var msg = "ERROR";
                msg = TextUtil.Error(msg);
                TerminalUtil.ShowText(msg);
            }
        }
Пример #5
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                var path = options.ParsedArguments[0].Value;

                HashDir  dir;
                HashFile file;

                if (FileSystem.DirExists(path, out dir))
                {
                    FileSystem.ChangeDir(dir);
                }
                else if (FileSystem.FileExistsAndIsAvailable(path, out file))
                {
                    var msg = string.Format("The path '{0}' points to a file. Use 'open {0}' to open this file.", path);
                    msg = TextUtil.Warning(msg);
                    TerminalUtil.ShowText(msg);
                }
                else
                {
                    var msg = string.Format("The path '{0}' points nowhere. Please supply a valid path.", path);
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
            }
            else
            {
                string msg    = null;
                var    result = PathValidation.ValidationResult;
                if (MathUtil.ContainsFlag((int)result, (int)ArgValidationResult.EmptyValue))
                {
                    msg = "Please supply a path.";
                }
                else if (MathUtil.ContainsFlag((int)result, (int)ArgValidationResult.NotFound))
                {
                    msg = "Please supply a path.";
                }

                msg = TextUtil.Error(msg);
                TerminalUtil.ShowText(msg);
            }
        }
Пример #6
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (options.ParsedArguments.Count > 0)
            {
                var programName = options.ParsedArguments[0].Value;
                var program     = Shell.FindProgramByCommand(programName);
                if (program == null)
                {
                    var msg =
                        "'{0}' is not a valid program. You can use 'help' to see help for all programs or 'help <program_name>' to see help about a specific program";
                    msg = TextUtil.ApplyNGUIColor(msg, Constants.Colors.Error);
                    TerminalUtil.ShowText(msg);
                }
                else
                {
                    ShowHelpFor(program);
                    ShowProgramsUsage();
                }
            }
            else
            {
                TerminalUtil.StartTextBatch();

                var programs = ProgramUtil.GetAvailablePrograms(DataHolder.DeviceData.CurrentDevice);
                for (int i = 0; i < programs.Count; i++)
                {
                    var program = programs[i];
                    ShowHelpFor(program);
                }

                ShowProgramsUsage();

                TerminalUtil.EndTextBatch();
            }
        }
Пример #7
0
        /// <summary>
        /// Finds the program that corresponds to the given commandName.
        /// If none is found, null is returned.
        /// </summary>
        public static Program FindProgramByCommand(string commandName)
        {
            var programs = DataHolder.DeviceData.CurrentDevice.AllPrograms;

            for (int i = 0; i < programs.Count; i++)
            {
                var prog = programs[i];
                for (int j = 0; j < prog.Commands.Length; j++)
                {
                    var command = prog.Commands[j];
                    if (string.Equals(command, commandName, StringComparison.InvariantCultureIgnoreCase))
                    {
                        if (ProgramUtil.IsProgramAvailable(prog))
                        {
                            return(prog);
                        }
                    }
                }
            }

            return(null);
        }
Пример #8
0
 public static void FillCommandBuffer()
 {
     FileSystem.FilleCommandBufferWithFileSystem(FillBufferFileSystemOptions.IncludeDir);
     ProgramUtil.AddPrefixToCommandBuffer("cd ");
 }
Пример #9
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                Pair <string, string> pathArg;

                // no need to validate this because the argument is required
                CommandLineUtil.TryGetArgumentByName(options.ParsedArguments, PathArgName, out pathArg);
                var path = pathArg.Value;

                bool openOnTerminal = CommandLineUtil.ArgumentExists(options.ParsedArguments, TerminalArgName);

                HashFile file;
                HashDir  dir;
                if (FileSystem.FileExistsAndIsAvailable(path, out file))
                {
                    var permission = FileSystem.GetAccessPermission(file);
                    if (permission < AccessPermission.Editable)
                    {
                        var msg = "You don't have permission to open this file.";
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                    }
                    else
                    {
                        switch (file.FileType)
                        {
                        case HashFileType.Text:
                            var textFile = file.Content as TextFile;
                            OpenTextFile(file, textFile, openOnTerminal);
                            break;

                        case HashFileType.Image:
                            var imageFile = file.Content as ImageFile;
                            OpenImageFile(file, imageFile, openOnTerminal);
                            break;

                        default:
                            DebugUtil.Error(string.Format("The open program can't open file type: {0}", file.FileType));
                            break;
                        }
                    }
                }
                else
                {
                    string msg;
                    if (FileSystem.DirExists(path, out dir))
                    {
                        msg = "The path '{0}' points to a directory. Please use 'cd {0}' to navigate to that directory.";
                    }
                    else
                    {
                        msg = "The path '{0}' points to nowhere. Please supply a valida path.";
                    }

                    msg = string.Format(msg, path);
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
            }
            else
            {
                string msg = "Please supply a file path.";
                msg = TextUtil.Error(msg);
                TerminalUtil.ShowText(msg);
            }
        }
Пример #10
0
        public static bool HasProgram(HashDevice device, ProgramType programType)
        {
            var programs = ProgramUtil.GetAvailablePrograms(device);

            return(SList.Exists(programs, p => p.ProgramType == programType));
        }
Пример #11
0
        /// <summary>
        /// Executes the dir program.
        /// </summary>
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            HashDir currentDir = null;

            if (options.ParsedArguments.Count == 0)
            {
                currentDir = DataHolder.DeviceData.CurrentDevice.FileSystem.CurrentDir;
            }
            else
            {
                var desiredDirPath = options.ParsedArguments[0].Value;
                if (!FileSystem.DirExists(desiredDirPath, out currentDir))
                {
                    string msg;

                    HashFile file;
                    if (FileSystem.FileExistsAndIsAvailable(desiredDirPath, out file))
                    {
                        msg = string.Format("The path '{0}' points to a file. Use 'open {0}' to open this file.",
                                            desiredDirPath);
                    }
                    else
                    {
                        msg = string.Format("The path '{0}' points nowhere. Please supply a valid path.",
                                            desiredDirPath);
                    }

                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                    return;
                }
            }

            var childs = FileSystem.GetAllAvailableChild(currentDir);
            var files  = FileSystem.GetAvailableFilesFromDir(currentDir);

            if (childs.Count == 0 && files.Count == 0)
            {
                var txt = "EMPTY DIRECTORY!";
                txt = TextUtil.ApplyNGUIColor(txt, LineColor);
                TerminalUtil.ShowText(txt);
            }
            else
            {
                TerminalUtil.StartTextBatch();

                TerminalUtil.ShowText(HeaderLine.FormattedText);

                for (int i = 0; i < childs.Count; i++)
                {
                    var child = childs[i];
                    var line  = CreateLine(child.Name, "DIRECTORY", string.Empty, LineColor, TextModifiers.Italic);
                    TerminalUtil.ShowText(line.FormattedText);
                }

                for (int i = 0; i < files.Count; i++)
                {
                    var file = files[i];

                    var status = FileSystem.GetStatusString(file.Status);
                    var line   = CreateLine(file.FullName, "FILE", status, LineColor, TextModifiers.Italic);
                    TerminalUtil.ShowText(line.FormattedText);
                }

                TerminalUtil.EndTextBatch();
            }
        }
Пример #12
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                Pair <string, string> pathArg     = CommandLineUtil.FindArgumentByName(options.ParsedArguments, PathArgName);
                Pair <string, string> passwordArg = CommandLineUtil.FindArgumentByName(options.ParsedArguments, PasswordArgName);

                var path     = pathArg.Value;
                var password = passwordArg.Value;

                HashFile file = FileSystem.FindFileByPath(path);
                if (file == null)
                {
                    var msg = string.Format("The path '{0}' is not a valid file path.", path);
                    ShowErrorMessage(msg);
                }
                else
                {
                    if (file.Status != FileStatus.Encrypted)
                    {
                        var msg = string.Format("The file '{0}' is not encrypt. You can open it using 'open {0}'", path);
                        msg = TextUtil.ApplyNGUIColor(msg, Constants.Colors.Success);
                        TerminalUtil.ShowText(msg);
                    }
                    else
                    {
                        var filePassword = file.Password;
                        if (string.Equals(password, filePassword))
                        {
                            var msg = string.Format("File '{0}' decrypted successfully. Use 'open {0}' to open the file.", path);
                            msg = TextUtil.ApplyNGUIColor(msg, Constants.Colors.Success);
                            TerminalUtil.ShowText(msg);
                            FileSystem.ChangeFileStatus(file, FileStatus.Normal);
                        }
                        else
                        {
                            var msg = "Invalid password.";
                            ShowErrorMessage(msg);
                        }
                    }
                }
            }
            else
            {
                var pathResult     = (int)PathValidation.ValidationResult;
                var passwordResult = (int)PasswordValidation.ValidationResult;
                if (MathUtil.ContainsFlag(pathResult, (int)ArgValidationResult.NotFound) ||
                    MathUtil.ContainsFlag(pathResult, (int)ArgValidationResult.EmptyValue))
                {
                    var msg = "You need to supply a path. Please use 'help cracker' for more info.";
                    ShowErrorMessage(msg);
                }
                else if (MathUtil.ContainsFlag(passwordResult, (int)ArgValidationResult.NotFound) ||
                         MathUtil.ContainsFlag(passwordResult, (int)ArgValidationResult.EmptyValue))
                {
                    var msg = "You need to supply a password. Please use 'help cracker' for more info.";
                    ShowErrorMessage(msg);
                }
            }
        }
Пример #13
0
        public static void Execute(ProgramExecutionOptions options)
        {
            if (ProgramUtil.ShowHelpIfNeeded(options))
            {
                return;
            }

            bool      everythingOk = true;
            int       count        = 0;
            ClearMode mode         = ClearMode.Top;

            if (options.ParsedArguments.Count == 0)
            {
                count = DataHolder.TerminalData.AllEntries.Count;
            }
            else if (CommandLineUtil.ValidateArguments(options.ParsedArguments, Validations))
            {
                Pair <string, string> modeArg;
                Pair <string, string> countArg;

                bool modePresent =
                    CommandLineUtil.TryGetArgumentByName(options.ParsedArguments, ModeArgName, out modeArg);
                bool countPresent =
                    CommandLineUtil.TryGetArgumentByName(options.ParsedArguments, CountArgName, out countArg);

                if (modePresent && !countPresent)
                {
                    var msg = "You need to supply the number of line to clear when using the mode argument.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                    everythingOk = false;
                }

                if (countPresent && !modePresent)
                {
                    var msg =
                        "You need to supply the mode argument when removing a specific quantity of lines.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                    everythingOk = false;
                }

                if (everythingOk)
                {
                    if (!MiscUtil.TryParseEnum(modeArg.Value, out mode))
                    {
                        var msg = string.Format("'{0}' is not a valid clear mode. It must be either 'top' or 'down'.",
                                                modeArg.Value);
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                        everythingOk = false;
                    }
                    else if (!int.TryParse(countArg.Value, out count))
                    {
                        var msg = string.Format("'{0}' is not a valid number of lines!", countArg.Value);
                        msg = TextUtil.Error(msg);
                        TerminalUtil.ShowText(msg);
                        everythingOk = false;
                    }
                }
            }
            else
            {
                everythingOk = false;

                var modeResult  = ModeValidation.ValidationResult;
                var countResult = CountValidation.ValidationResult;

                if (MathUtil.ContainsFlag((int)modeResult, (int)ArgValidationResult.EmptyValue))
                {
                    var msg = "The 'mode' argument must be either 'top' or 'down'.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
                else if (MathUtil.ContainsFlag((int)modeResult, (int)ArgValidationResult.Duplicated))
                {
                    var msg = "Please supply only one 'mode' argument.";
                    msg = TextUtil.Error(msg);
                    TerminalUtil.ShowText(msg);
                }
            }

            if (everythingOk)
            {
                if (mode == ClearMode.Bottom)
                {
                    TerminalUtil.RemoveTextEntries(count, TerminalEntryRemoveType.NewerEntries);
                }
                else
                {
                    TerminalUtil.RemoveTextEntries(count, TerminalEntryRemoveType.OlderEntries);
                }
            }
        }