C#

Quote:

I need it so that the program continues to run in stealth mode so that no one knows it's installed on the computer.

Quote:

the string str = "123456GCTJ" and str.length = 10

Psudonym wrote:

Question 1. How to get the string length? Do I have to write my own function? or Do I have to define a public class and associate it with the string like... str.getlengthForIntel()

Psudonym wrote:

Checksum (how to get the checksum?

string strLine;
int iBytelen;
long lBaseAddress = 0x7830;
string subString;
string strTempStrForChecksum;
uint iLoopcntr, iLoopcntrcopy;
int index;

    subString = strLine.Trim().Substring(0, strLine.Length - 1);
            strTempStrForChecksum = ":" + iBytelen.ToString("X") + lBaseAddress.ToString("X") + "00" + subString;
            strTempStrForChecksum += GetChecksum(strTempStrForChecksum);
            pFile.Write(strTempStrForChecksum + "\n");

strTempStrForChecksum = ":" + iBytelen.ToString("X") + lBaseAddress.ToString("X") + "00" + subString;

string strLine;
           int iBytelen;
           long lBaseAddress = 0x7830;
           string subString;
           string strTempStrForChecksum;
           uint iLoopcntr, iLoopcntrcopy;
           int index;

               subString = strLine.Trim().Substring(0, strLine.Length - 1);
                       strTempStrForChecksum = ":" + iBytelen.ToString("X") + lBaseAddress.ToString("X") + "00" + subString;
                       strTempStrForChecksum += GetChecksum(strTempStrForChecksum);
                       pFile.Write(strTempStrForChecksum + "\n");

        private string ToHexString(string str)
        {
            var sb = new StringBuilder();

            var bytes = Encoding.Unicode.GetBytes(str);
            //foreach (var t in bytes)
            //{
            //    sb.Append(t.ToString("X"));
            //}

            for(int i=0; i<str.Length; i++)
            {
                byte b = (byte)str[i];
                sb.Append(b.ToString("X"));
            }

            return sb.ToString(); 
        }
    }
}

Quote:

:107830003132313131303031323331323334363120

private string GetChecksum(string strData)
       {
           byte checksum = 0;
           char[] DataArray = strData.ToCharArray();
           byte ArrayLen = 0;
           string strAscii;

           //Add all bytes of the string
           while (ArrayLen < strData.Length)
           {
               if ((DataArray[ArrayLen]) != ':')
               {
                   checksum += (byte)DataArray[ArrayLen];
               }
               ArrayLen++;
           }

           //1's complement of the addition
           checksum = (byte)(~(int)checksum);

           //2's complement of the addition
           checksum += 1;

           strAscii = ((checksum & 0xF0) >> 4).ToString("X") + (checksum & 0x0F).ToString("X");
           return strAscii;
       }

namespace VistaBalanceAlgorithms
{
    public class VerticalForce
    {
        public static float SteadyStateTotalForce = 1;
        public static bool SteadyState = false;

        public VerticalForce(float[] frameValues)
        {
            Left = 0;
            Right = 0;
            Total = 0;

            if (frameValues != null)
            {
                float leftForce = frameValues.Take(frameValues.Length / 2).Sum();
                float rightForce = frameValues.Skip(frameValues.Length / 2).Sum();
                Left = (int)((leftForce / SteadyStateTotalForce) * 100);
                Right = (int)((rightForce / SteadyStateTotalForce) * 100);

                Left = Left < 0 ? 0 : Left;
                Right = Right < 0 ? 0 : Right;

                Total = Left + Right;
            }
        }

        public int Left { get; protected set; }
        public int Right { get; protected set; }
        public int Total { get; protected set; }
    }

    public  class VerticalForceGraph
    {
        private List<VerticalForce> vtfList = new List<VerticalForce>();

        public int BufferSize { get; set; }

        public void Add(VerticalForce vtf)
        {
            vtfList.Add(vtf);

            // remove first item if condition
            if(vtfList.Count > BufferSize)
            {
               // vtfList.RemoveRange(1, 1);
                vtfList.RemoveAt(0);
              
            }
        }

        public int[] GetLeftVTF()
        {
           return vtfList.Select(x => x.Left).ToArray();
        }

        public int[] GetRightVTF()
        {
            return vtfList.Select(x => x.Right).ToArray();
        }

        public int[] GetTotalVTF()
        {
            return vtfList.Select(x => x.Total).ToArray();
        }


    }
}

private void HeatmapViewMode(Graphics graphics)
        {
            graphics.SmoothingMode = SmoothingMode.AntiAlias;

            //draw border
            graphics.DrawRectangle(borderPen, new Rectangle(heatmapCoord_X, heatmapCoord_Y, heatmapWidth, heatmapHeight));
            // Draw CoP point & tail
            Pen semiTransPen = new Pen(Color.FromArgb(128, 0, 0, 255), 3);
            var points = m_CopTail.GetPoints().Select(c => { c.X = c.X - m_AutocenterOffsetX; c.Y = c.Y - m_AutocenterOffsetY; return c; }).ToArray();
            if (points != null && points.Length > 1)
            {
                SizeF copPointSize = new SizeF(10, 10);
                SizeF centerOffset = new SizeF(copPointSize.Width / 2, copPointSize.Height / 2);
                PointF copPoint = new PointF(COP.X - m_AutocenterOffsetX - centerOffset.Width,
                                             COP.Y - m_AutocenterOffsetY - centerOffset.Height);


                graphics.FillEllipse(Brushes.Red, new RectangleF(copPoint, copPointSize));

                if (m_CopTail.TimeRange.TotalSeconds > 0)
                    graphics.DrawCurve(semiTransPen, points);

                if ((Mode == ModeOfOperation.STABILITY_MODE && m_CopTail.HasAutoCenter() == true) ||
                    (m_CopTail.HasAutoCenter() == true && CopArrow == true))
                {
                    PointF centerPoint = new PointF(heatmapCoord_X + heatmapWidth / 2f,
                      heatmapCoord_Y + heatmapHeight / 2f);

                    PointF endPoint = new PointF(copPoint.X + centerOffset.Width, copPoint.Y + centerOffset.Height);

                    var distance = Math.Sqrt(Math.Pow((centerPoint.X - endPoint.X), 2) + Math.Pow((centerPoint.Y - endPoint.Y), 2));

                    float triggerZoneDiameter = 30f;
                    StabilityTriggerZoneDraw(graphics, triggerZoneDiameter, distance > triggerZoneDiameter);

                    graphics.DrawLine(stabilityArrowPen, centerPoint, endPoint);
                }


                if (heatmap != null)
                    heatmap.Draw(graphics, heatmapCoord_X - m_AutocenterOffsetX, heatmapCoord_Y - m_AutocenterOffsetY, 80);
            }
        }