protected override bool OnKeyPressEvent(EventKey evnt)
{
KeyboardCode code;
switch (evnt.Key)
{
case Gdk.Key.Up: code = KeyboardCode.ArrowUp; break;
case Gdk.Key.Down: code = KeyboardCode.ArrowDown; break;
case Gdk.Key.Left: code = KeyboardCode.ArrowLeft; break;
case Gdk.Key.Right: code = KeyboardCode.ArrowRight; break;
case Gdk.Key.BackSpace: code = KeyboardCode.Backspace; break;
default:
if (evnt.KeyValue >= 32 && evnt.KeyValue < 127)
{
code = KeyboardCode.NormalChar;
}
else
{
code = KeyboardCode.Unknown;
}
break;
}
IKeyEvent keyEvent = new GtkKeyEvent(this, evnt.KeyValue, code);
CanvasModel.HandleKeyPressEvent(keyEvent);
base.OnKeyPressEvent(evnt);
return(true);
}
public CanvasView(Graphics graphics, CanvasModel canvas, Color backColor, TextBox debugOutput)
{
_graphics = graphics;
_canvas = canvas;
_backColor = backColor;
_debugOutput = debugOutput;
}
public static CanvasModel GetCanvasModel(string input)
{
CanvasModel model = null;
string[] values = input.Split(' ');
uint width = 0, height = 0;
if (values.Length != 3 || values[0].ToUpper() != "C")
{
throw new ArgumentOutOfRangeException("Canvas dimensions are not valid!");
}
if (uint.TryParse(values[1], out width) && width > 0 && uint.TryParse(values[2], out height) && height > 0)
{
model = new CanvasModel();
model.Width = width;
model.Height = height;
}
else
{
throw new ArgumentOutOfRangeException("Canvas dimensions must be positive integers!");
}
return(model);
}
/// <summary>
/// Method to open a scribble file
/// </summary>
private void Open()
{
// create a instance of file dialog box to specify the file
Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog();
openFileDialog.Filter = CanvasConstants.FileType;
// call showDialog to display the file dialog
if (openFileDialog.ShowDialog() == true)
{
// Call service method to deserialize the file contents into Model
DataService.CanvasService canvasService = new DataService.CanvasService();
CanvasModel canvasModel = canvasService.Read(openFileDialog.FileName);
for (int i = 0; i < canvasModel.Points.Length; i++)
{
if (canvasModel.Points[i] != null)
{
// Call the extension method to convet the points array to storke
var strokes = canvasModel.Points[i].GenerateStroke((DrawingMode)canvasModel.Modes[i]);
// add the stroke to the collection
this.Strokes.Add(strokes);
}
}
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
runButton.IsEnabled = false;
chart.ClearChart();
try
{
if (!Validation.GetHasError(gridOptions) &&
gridOptions.Children.Cast <Control>().All(x => !Validation.GetHasError(x)))
{
var result = await Task.Run(() => _emulatorService.Run(optionsModel.Options));
canvasModel.Lines = CanvasModel.GetLines(result);
}
else
{
throw new Exception("ошибка в опциях");
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, ex.GetType().Name, MessageBoxButton.OK, MessageBoxImage.Error);
}
runButton.IsEnabled = true;
}
private void GraphGUI_Load(object sender, EventArgs e)
{
var canvas = new CanvasModel(10);
_canvasController = new CanvasController(canvas);
_canvasView = new CanvasView(drawPanel.CreateGraphics(), canvas, drawPanel.BackColor, debugOutput);
_canvasView.Render();
}
public DetailsDialog(CCanvas activeCanvas, CanvasModel cm)
{
InitializeComponent();
this.DataContext = activeCanvas;
_activeCanvas = activeCanvas;
_allTags = cm.allTags;
_currentTags = _activeCanvas.tags.ToList();
}
/// <summary>
/// Method to write the serialized data in the given location
/// </summary>
/// <param name="fileName">file Name</param>
/// <param name="canvasModel">canvas model</param>
public void Write(string fileName, CanvasModel canvasModel)
{
FileStream fs = new FileStream(fileName, FileMode.Create);
XmlSerializer serializer = new XmlSerializer(canvasModel.GetType());
StreamWriter writer = new StreamWriter(fs);
serializer.Serialize(writer, canvasModel);
fs.Close();
}
private void DispatchPointerEvent(PointerEventType type, double ex,
double ey, ModifierType mods)
{
GtkPointerEvent outEvent = pointerEvent;
if (outEvent.Update(type, ex, ey, mods))
{
CanvasModel.HandlePointerEvent(outEvent);
}
}
/// <summary>
/// Method to read and deserialize the data
/// </summary>
/// <param name="fileName">file name</param>
/// <returns>canvas model</returns>
public CanvasModel Read(string fileName)
{
FileStream fs = new FileStream(fileName, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(CanvasModel));
StreamReader reader = new StreamReader(fs);
CanvasModel canvasModel = (CanvasModel)serializer.Deserialize(reader);
fs.Close();
return(canvasModel);
}
public CalicoViewModel(CanvasModel cm, WorkspaceModel wm)
{
_canvasModel = cm;
_workspaceModel = wm;
navPanelWidth = 175;
detailPanelHeight = 150;
allCanvasesView = CollectionViewSource.GetDefaultView(allCanvases);
selectedTags = new List <string>();
selectedUsers = new List <string>();
searchTerm = "";
navItemHeight = 50;
}
protected override bool OnExposeEvent(EventExpose args)
{
base.OnExposeEvent(args);
Context context = CairoHelper.Create(args.Window);
IPaintbrush pb = new GtkPaintbrush(this, context);
CanvasModel.Paint(pb);
(context.Target as IDisposable).Dispose();
(context as IDisposable).Dispose();
return(true);
}
private void ChartControl_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
if (Model != null)
{
Model.PropertyChanged -= SetLines;
}
Model = e.NewValue as CanvasModel;
if (Model != null)
{
Model.PropertyChanged += SetLines;
}
}
public WorkspaceViewModel(CanvasModel cm, WorkspaceModel wm) : base(cm, wm)
{
_canvasModel = cm; //protected field in base class
_workspaceModel = wm; //protected field in base class
activeWS = allWorkspaces[0];
navPanelWidth = 175;
detailPanelHeight = 150;
allCanvasesView = CollectionViewSource.GetDefaultView(allCanvases);
selectedTags = new List <string>();
selectedUsers = new List <string>();
searchTerm = "";
navItemHeight = 50;
}
public static GraphDto ToGraphDto(CanvasModel canvas)
{
var graphDto = new GraphDto()
{
Nodes = new List <NodeDto>(canvas.Nodes.ConvertAll(ToNodeDto)),
Edges = new List <EdgeDto>(canvas.Edges.ConvertAll(ToEdgeDto))
};
foreach (var terminal in canvas.Terminals)
{
graphDto.Nodes.Find(node => node.Id == terminal.Id).IsTerminal = true;
}
return(graphDto);
}
private void Init()
{
_emulatorService = new EmulatorService(new StatisticsService(), new LuckCalculationService());
chart.DataContext = canvasModel = new();
gridOptions.DataContext = optionsModel = new()
{
Repeat = 10,
GuarantFiveWin = 90,
ChanceFiveWinPercente = 0.6M,
GuarantFourWin = 10,
ChanceFourWinPercente = 5.1M,
UserOptionsAttemptsMax = 100,
UserOptionsAttemptsMin = 50,
UserOptionsCount = 18000,
UserOptionsPresetMax = 89,
UserOptionsPresetMin = 0,
StopAfterGuarantUserOptionsAttemptsMax = 100,
StopAfterGuarantUserOptionsAttemptsMin = 50,
StopAfterGuarantUserOptionsCount = 20000,
StopAfterGuarantUserOptionsPresetMax = 89,
StopAfterGuarantUserOptionsPresetMin = 0,
StopAfterGuarantWithLargePresetUserOptionsAttemptsMax = 100,
StopAfterGuarantWithLargePresetUserOptionsAttemptsMin = 50,
StopAfterGuarantWithLargePresetUserOptionsCount = 20000,
StopAfterGuarantWithLargePresetUserOptionsPresetMax = 70,
StopAfterGuarantWithLargePresetUserOptionsPresetMin = 50,
StopAfterGuarantWithoutLimitUserOptionsCount = 2000,
StopAfterGuarantWithoutLimitUserOptionsPresetMax = 89,
StopAfterGuarantWithoutLimitUserOptionsPresetMin = 0,
StopBeforeGuarantUserOptionsAttemptsMax = 100,
StopBeforeGuarantUserOptionsAttemptsMin = 50,
StopBeforeGuarantUserOptionsCount = 20000,
StopBeforeGuarantUserOptionsPresetMax = 70,
StopBeforeGuarantUserOptionsPresetMin = 0,
StopBeforeGuarantUserOptionsStopIndexMax = 70,
StopBeforeGuarantUserOptionsStopIndexMin = 50,
ExpectationFourWinUserOptionsAttemptsMax = 100,
ExpectationFourWinUserOptionsAttemptsMin = 50,
ExpectationFourWinUserOptionsCount = 20000,
ExpectationFourWinUserOptionsPresetMax = 89,
ExpectationFourWinUserOptionsPresetMin = 0,
ExpectationFourWinUserOptionsCountMax = 10,
ExpectationFourWinUserOptionsCountMin = 3
};
Button_Click(null, null);
}
public static CanvasModel GetObjectByPage(IContent node)
{
try
{
string json = node.GetValue <string>("canvas");
var model = new CanvasModel();
if (!string.IsNullOrEmpty(json))
{
model = JsonConvert.DeserializeObject <CanvasModel>(json);
}
return(model);
}
catch (Exception ex)
{
Log.Error("Canvas error on GetObjectByPage in Repository.", ex);
return(null);
}
}
public static CanvasModel GetObjectByNode(IPublishedContent node)
{
try
{
var model = new CanvasModel();
if (node.HasProperty("canvas") && node.HasValue("canvas"))
{
string json = node.GetPropertyValue <string>("canvas");
model = JsonConvert.DeserializeObject <CanvasModel>(json);
}
return(model);
}
catch (Exception ex)
{
Log.Error("Canvas error on GetObjectByNode in Repository.", ex);
return(null);
}
}
public static bool SaveJson(CanvasModel model, int pageId)
{
try
{
var node = cs.GetById(pageId);
var newJson = JsonConvert.SerializeObject(model, Formatting.None);
node.SetValue("canvas", newJson.ToString());
var currentUser = Authorize.GetCurrentUser();
cs.Save(node, currentUser.Id);
return(true);
}
catch (Exception ex)
{
Log.Error("Canvas error on SaveJson in Repository.", ex);
return(false);
}
}
public void Create()
{
if (_canvasHeight < 0 || _canvasWidth < 0)
{
MessageBox.Show("The canvas size must be positive.");
return;
}
if (String.IsNullOrWhiteSpace(_canvasName))
{
MessageBox.Show("The name is not valid");
return;
}
CanvasCreationMessage ccm = new CanvasCreationMessage();
CanvasModel canvas = new CanvasModel();
canvas.Height = _canvasHeight;
canvas.Width = _canvasWidth;
canvas.Name = _canvasName;
ccm.Canvas = canvas;
ccm.IsDoneAdding = true;
_eventAggregator.PublishOnCurrentThread(ccm);
TryClose();
}
/// <summary>
/// Method to save the canvas strokes
/// </summary>
private void Save()
{
CanvasModel canvasModel = new CanvasModel();
// Call the extension method to convert the strokes in to point array
canvasModel.Points = this.Strokes.GeneratePointArray();
// Call the extension method to get the drawing modes of strokes
canvasModel.Modes = this.Strokes.GetDrawingModes();
// create a instance of file dialog box to specify the file name and location for save
Microsoft.Win32.SaveFileDialog saveFileDialog = new Microsoft.Win32.SaveFileDialog();
// Set the filter that determines the file type
saveFileDialog.Filter = CanvasConstants.FileType;
if (saveFileDialog.ShowDialog() == true)
{
DataService.CanvasService canvasService = new DataService.CanvasService();
// call the service method to serialize and save the the contents
canvasService.Write(saveFileDialog.FileName, canvasModel);
}
}
public JsonResult AddControl(string areaAlias, string controlType, int pageId)
{
var controlId = Guid.NewGuid();
string columns = "6:medium:;6:medium:";
var model = Repository.GetObjectById(pageId);
if (model != null && !string.IsNullOrEmpty(controlType) && !string.IsNullOrEmpty(areaAlias))
{
// Find Area In Grid/Section or Root
foreach (var area in model.Areas)
{
FindArea(area, areaAlias);
}
if (AreaResult != null)
{
var control = new CanvasControl
{
ControlID = controlId,
Type = controlType
};
// If control is grid then create area inside it
if (controlType == "Grid")
{
control.Columns = columns;
int p = 0;
foreach (var column in columns.Split(';').Where(x => !string.IsNullOrEmpty(x)))
{
string col = column.Split(':')[0];
var area = new CanvasArea {
Alias = "grid-" + col + "-" + controlId.ToString() + "-" + p
};
control.Areas.Add(area);
p++;
}
}
// If control is section then create area inside it
if (controlType == "Section")
{
var area = new CanvasArea {
Alias = "section-" + controlId.ToString()
};
control.Areas.Add(area);
}
AreaResult.Controls.Add(control);
}
// Convert model back to json for saving
Repository.SaveJson(model, pageId);
}
else
{
// If no area is found, create it
var m = new CanvasModel();
var area = new CanvasArea {
Alias = areaAlias
};
var control = new CanvasControl
{
ControlID = controlId,
Type = controlType
};
area.Controls.Add(control);
m.Areas.Add(area);
Repository.SaveJson(m, pageId);
}
return(Json(new { success = true, controlType = controlType, controlId = controlId.ToString(), pageId = pageId }));
}
public static CanvasView Get(string alias, bool isAuthenticated)
{
try
{
var View = new CanvasView();
int pageId = UmbracoContext.Current.PageId.Value;
if (isAuthenticated)
{
var cs = ApplicationContext.Current.Services.ContentService;
var page = cs.GetById(pageId);
var model = Repository.GetObjectById(pageId);
// Find area recurcivly
if (model.Areas.All(x => x.Alias != alias))
{
// Did not find area
// Check if there is a root area, create it if not.
Log.Info("Canvas - Did not find area, try to create it: " + alias);
var area = new CanvasArea();
area.Alias = alias;
if (model.Areas.Any())
{
// Append new
model.Areas.Add(area);
Repository.SaveJson(model, pageId);
page = cs.GetById(pageId);
}
else
{
// Create new
var areaModel = new CanvasModel();
areaModel.Areas.Add(area);
Repository.SaveJson(areaModel, pageId);
page = cs.GetById(pageId);
}
}
View.page = page;
View.viewName = "/Views/Canvas/Backend.cshtml";
}
else
{
View.node = UmbracoContext.Current.ContentCache.GetById(pageId);
View.viewName = "/Views/Canvas/FrontEnd.cshtml";
}
View.alias = alias;
return(View);
}
catch (Exception ex)
{
Log.Error("Canvas error on Get in ViewHelper.", ex);
return(null);
}
}
private async static Task Main(string[] args)
{
try
{
if (!ParseArguments(args))
{
return;
}
logger = new Logger(options?.LogFilePath, finishCTS.Token)
{
ShowDebugLogs = options?.ShowDebugLogs ?? false
};
if (checkUpdates || !options.DisableUpdates)
{
if (UpdateChecker.IsStartingUpdate(logger, checkUpdates) || checkUpdates)
{
return;
}
}
logger.LogTechState("Loading data from file...");
try
{
LoadFile(options.FileName);
}
catch (Exception ex)
{
logger.LogError($"Error during loading file: {ex.Message}");
}
logger.LogInfo($"File is loaded: {w}x{h}, {deltas.Count + 1} frames");
logger.LogTechState("Downloading palette...");
PixelPlanetHttpApi api = new PixelPlanetHttpApi
{
ProxySettings = proxySettings
};
UserModel user = await api.GetMeAsync();
logger.LogTechInfo("Palette retrieved");
CanvasModel canvas = user.Canvases[canvasType];
palette = new Palette(canvas.Colors);
DirectoryInfo dir = Directory.CreateDirectory($"seq_{startTime:MM.dd_HH-mm}");
string pathTemplate = Path.Combine(dir.FullName, "{0:MM.dd_HH-mm-ss}.png");
try
{
SaveLoadedData(pathTemplate);
}
catch (Exception ex)
{
logger.LogError($"Error during saving results: {ex.Message}");
}
}
catch (Exception ex)
{
logger?.LogError($"Unhandled app level exception: {ex.Message}");
logger?.LogDebug(ex.ToString());
}
finally
{
if (logger != null)
{
logger.LogInfo("Exiting...");
logger.LogInfo($"Logs were saved to {logger.LogFilePath}");
}
finishCTS.Cancel();
if (logger != null)
{
Thread.Sleep(500);
}
logger?.Dispose();
finishCTS.Dispose();
Console.ForegroundColor = ConsoleColor.White;
Environment.Exit(0);
}
}
public EditorViewModel(CanvasModel cm, WorkspaceModel wm) : base(cm, wm)
{
_canvasModel = cm;
_workspaceModel = wm;
_activeCanvas = new CCanvas();
}
public void LoadState(out CanvasModel cm, out WorkspaceModel wm)
{
string dataPath = ".\\data";
string path = dataPath + "\\canvasstate.xml";
if (File.Exists(path))
{
XmlSerializer x = new XmlSerializer(typeof(CanvasModel));
CanvasModel tempModel;
using (XmlReader xReader = XmlReader.Create(path))
{
tempModel = (CanvasModel)x.Deserialize(xReader);
}
foreach (CCanvas c in tempModel.allCanvases)
{
c.LoadFromFile(dataPath);
}
cm = tempModel;
}
else
{
cm = new CanvasModel();
}
path = dataPath + "\\workspacestate.xml";
if (File.Exists(path))
{
XmlSerializer x = new XmlSerializer(typeof(WorkspaceModel));
WorkspaceModel tempModel;
using (XmlReader xReader = XmlReader.Create(path))
{
tempModel = (WorkspaceModel)x.Deserialize(xReader);
}
foreach (Workspace ws in tempModel.allWorkspaces)
{
foreach (SketchThumbnail s in ws.Sketches)
{
CCanvas ancestor = cm[s.canvasID];
s.thumbnail = ancestor.getThumbnail();
s.canvas = ancestor;
}
}
wm = tempModel;
foreach (Workspace ws in _wsModel.allWorkspaces)
{
ws.LoadNotesFromFile(dataPath);
}
}
else
{
wm = new WorkspaceModel();
wm.Initialize();
}
}
public CanvasController(CanvasModel canvas)
{
_canvas = canvas;
}
private static async Task Main(string[] args)
{
try
{
if (!ParseArguments(args))
{
return;
}
logger = new Logger(options?.LogFilePath, finishCTS.Token)
{
ShowDebugLogs = options?.ShowDebugLogs ?? false
};
logger.LogDebug("Command line: " + Environment.CommandLine);
logger.LogTechState("Connecting to API...");
PixelPlanetHttpApi api = new PixelPlanetHttpApi
{
ProxySettings = proxySettings
};
user = await api.GetMeAsync();
logger.LogTechInfo("Successfully connected");
CanvasModel canvas = user.Canvases[options.Canvas];
if (canvas.Is3D)
{
throw new Exception("3D canvas is not supported");
}
LoggerExtensions.MaxCoordXYLength = 1 + (int)Math.Log10(canvas.Size / 2);
PixelMap.MapSize = canvas.Size;
try
{
if (options.LeftX < -(canvas.Size / 2) || options.RightX >= canvas.Size / 2)
{
throw new Exception("X");
}
if (options.TopY < -(canvas.Size / 2) || options.BottomY >= canvas.Size / 2)
{
throw new Exception("Y");
}
}
catch (Exception ex)
{
throw new Exception($"Entire rectangle should be inside the map (failed by {ex.Message})");
}
colorNameResolver = new ColorNameResolver(options.Canvas);
if (checkUpdates || !options.DisableUpdates)
{
if (UpdateChecker.IsStartingUpdate(logger, checkUpdates) || checkUpdates)
{
return;
}
}
cache = new ChunkCache2D(options.LeftX, options.TopY, options.RightX, options.BottomY, logger, options.Canvas);
bool initialMapSavingStarted = false;
saveThread = new Thread(SaveChangesThreadBody);
saveThread.Start();
if (string.IsNullOrWhiteSpace(options.FileName))
{
options.FileName = string.Format("pixels_({0};{1})-({2};{3})_{4:yyyy.MM.dd_HH-mm}.bin", options.LeftX, options.TopY, options.RightX, options.BottomY, DateTime.Now);
}
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(options.FileName)));
do
{
try
{
using (WebsocketWrapper wrapper = new WebsocketWrapper(logger, true, proxySettings, null, options.Canvas))
{
cache.Wrapper = wrapper;
if (!initialMapSavingStarted)
{
logger.LogDebug("Main(): initiating map saving");
initialMapSavingStarted = true;
lockingStreamTask = Task.Run(SaveInitialMapState);
}
wrapper.OnMapChanged += Wrapper_OnMapChanged;
stopListening = wrapper.StopListening;
Console.CancelKeyPress += (o, e) =>
{
logger.LogDebug("Console.CancelKeyPress received");
e.Cancel = true;
wrapper.StopListening();
};
logger.LogInfo("Press Ctrl+C to stop");
wrapper.StartListening();
break;
}
}
catch (Exception ex)
{
logger.LogError($"Unhandled exception: {ex.Message}");
Thread.Sleep(1000);
}
} while (true);
}
catch (Exception ex)
{
logger?.LogError($"Unhandled app level exception: {ex.Message}");
logger?.LogDebug(ex.ToString());
}
finally
{
if (logger != null)
{
logger.LogInfo("Exiting when everything is saved...");
logger.LogInfo($"Logs were saved to {logger.LogFilePath}");
}
finishCTS.Cancel();
if (logger != null)
{
Thread.Sleep(500);
}
finishCTS.Dispose();
logger?.Dispose();
Console.ForegroundColor = ConsoleColor.White;
if (saveThread != null && !saveThread.Join(TimeSpan.FromMinutes(1)))
{
Console.WriteLine("Save thread doesn't finish, aborting");
Environment.Exit(0);
}
}
}
public async Task Run()
{
if (options.Canvas == CanvasType.Moon)
{
throw new Exception("Moon canvas is not designed for bots");
}
if (options.SessionName != null)
{
logger.LogTechState("Loading session...");
SessionManager sessionManager = new SessionManager(proxySettings);
session = sessionManager.GetSession(options.SessionName);
logger.LogTechInfo("Session loaded");
}
logger.LogTechState("Connecting to API...");
PixelPlanetHttpApi api = new PixelPlanetHttpApi
{
ProxySettings = proxySettings,
Session = session
};
UserModel user = await api.GetMeAsync(finishToken);
logger.LogTechInfo("Successfully connected");
if (options.SessionName != null)
{
if (user.Name != null)
{
logger.LogTechInfo($"Session is alive; user \"{user.Name}\"");
}
else
{
throw new SessionExpiredException();
}
}
canvas = user.Canvases[options.Canvas];
LoggerExtensions.MaxCoordXYLength = 1 + (int)Math.Log10(canvas.Size / 2);
ValidateCanvas();
palette = new Palette(canvas.Colors, canvas.Is3D);
colorNameResolver = new ColorNameResolver(options.Canvas);
await LoadImage();
logger.LogTechState("Calculating pixel placing order...");
CalculateOrder();
logger.LogTechInfo("Pixel placing order is calculated");
InitCache();
mapUpdatedResetEvent = new ManualResetEvent(false);
cache.OnMapUpdated += (o, e) =>
{
logger.LogDebug("cache.OnMapUpdated event fired");
mapUpdatedResetEvent.Set();
};
if (options.DefenseMode)
{
gotGriefed = new AutoResetEvent(false);
cache.OnMapUpdated += (o, e) => gotGriefed.Set();
waitingGriefLockObject = new object();
}
Thread statsThread = new Thread(StatsCollectionThreadBody);
statsThread.Start();
do
{
try
{
using (WebsocketWrapper wrapper = new WebsocketWrapper(logger, false, proxySettings, session, options.Canvas))
{
wrapper.OnConnectionLost += (o, e) => mapUpdatedResetEvent.Reset();
cache.Wrapper = wrapper;
cache.DownloadChunks();
wrapper.OnMapChanged += LogMapChanged;
ClearPlaced();
bool wasChanged;
do
{
repeatingFails = false;
wasChanged = await PerformBuildingCycle(wrapper);
if (!wasChanged && options.DefenseMode)
{
logger.Log("Image is intact, waiting...", MessageGroup.Info);
lock (waitingGriefLockObject)
{
logger.LogDebug("Run(): acquiring grief waiting lock");
gotGriefed.Reset();
gotGriefed.WaitOne();
}
logger.LogDebug("Run(): got griefed");
await Task.Delay(ThreadSafeRandom.Next(500, 3000), finishToken);
}
} while (options.DefenseMode || wasChanged);
logger.Log("Building is finished", MessageGroup.Info);
}
return;
}
catch (Exception ex)
{
logger.LogError($"Unhandled exception: {ex.GetBaseException().Message}");
logger.LogDebug(ex.ToString());
int delay = repeatingFails ? 30 : 10;
repeatingFails = true;
logger.LogTechState($"Reconnecting in {delay} seconds...");
Thread.Sleep(TimeSpan.FromSeconds(delay));
continue;
}
} while (true);
}
static void Main(string[] args)
{
CanvasAppCommands command = CanvasAppCommands.OTHER;
CanvasModel canvasModel = null;
BaseCanvas baseCanvas = null;
string input = string.Empty;
do
{
try
{
Console.Write("Enter the command: ");
input = Console.ReadLine().Trim();
if (Helper.IsValidInput(input))
{
if (Helper.IsExitCommand(input))
{
break;
}
command = Helper.GetCommandName(input);
if (canvasModel == null)
{
canvasModel = ModelExtractor.GetCanvasModel(input);
baseCanvas = new BaseCanvas();
baseCanvas.crateCanvas(canvasModel.Width, canvasModel.Height);
}
if (canvasModel != null)
{
if (command == CanvasAppCommands.LINE)
{
LineModel lineModal = new LineModel();
lineModal = ModelExtractor.GetLineModal(input);
baseCanvas.addLine(lineModal.X1, lineModal.Y1, lineModal.X2, lineModal.Y2);
}
if (command == CanvasAppCommands.RECTANGLE)
{
RectangleModel rectangleModel = new RectangleModel();
rectangleModel = ModelExtractor.GetRectangleModel(input);
baseCanvas.addRectangle(rectangleModel.X1, rectangleModel.Y1, rectangleModel.X2, rectangleModel.Y2);
}
if (command == CanvasAppCommands.BUCKET_FILL)
{
BucketFillModel bucketFillModel = new BucketFillModel();
bucketFillModel = ModelExtractor.GetBucketFillModel(input);
baseCanvas.fill(bucketFillModel.X, bucketFillModel.Y, Convert.ToChar(bucketFillModel.Colour));
}
baseCanvas.draw();
}
}
else
{
Console.WriteLine("Invalid Command!!! Please try again...\n");
}
}
catch (InvalidCastException ex)
{
Console.WriteLine("ERROR: " + ex.Message);
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine("ERROR: " + ex.Message);
}
catch (ArgumentException ex)
{
Console.WriteLine("ERROR: " + ex.Message);
}
catch (InvalidOperationException ex)
{
Console.WriteLine("ERROR: " + ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Unable to create Canvas!!!");
Console.WriteLine("Please try again C 10 4 ==> C widht height \n");
}
input = string.Empty;
} while (command != CanvasAppCommands.QUIT);
}
