/*
* From Process To Process, Message Send,Recv
*/

namespace RecvPackage
{
    public class Program : Form
    {
        public const int WM_COPYDATA=0x004A;

        public struct COPYDATASTRUCT
        {
            public IntPtr dwData;
            public int dbData;
            public IntPtr lpData;
        }

        public Program()
        {
            //From FindWindow(), This Application is Detected!!
            //From FindWindow(), This Application is Detected!! //The KeyWord is Below String,,,,,
            this.Text = "RecvSendDataMonitoring";
        }

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);
            try
            {
                switch(m.Msg)
                {
                    case WM_COPYDATA :
                    COPYDATASTRUCT cds = (COPYDATASTRUCT)m.GetLParam(typeof(COPYDATASTRUCT));
                    byte[] recvData = new byte[cds.cbData];
                    Marshal.Copy(cds.lpData, recvData, 0, cds.cbData);
                    Console.WriteLine(Encoding.Default.GetString(recvData));

                    break;
                }
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Program());
        }
    }//end of class
}//end of namespace

            

/*
BackgroundWorker를 통해 조금 더 안전하게 이벤트 기반으로 비동기 처리를 진행하는 패턴 사용해보기 (RunWorkerAsync, IsBusy)

BackgroundWorker를 통해 조금 더 안전하게 이벤트 기반으로 비동기 처리를 진행하는 패턴 사용해보기 (RunWorkerAsync, IsBusy)

BackgroundWorker를 통해 조금 더 안전하게 이벤트 기반으로 비동기 처리를 진행하는 패턴 사용해보기 (RunWorkerAsync, IsBusy)

BackgroundWorker를 통해 조금 더 안전하게 이벤트 기반으로 비동기 처리를 진행하는 패턴 사용해보기 (RunWorkerAsync, IsBusy)
*/

1. ".." 은 현재 실행되는 모습이다. 예를 들어 마우스를 움직인다던지, 키보드를 사용한다던지, 어떤 행위를 하는
2. 메세지는 백그라운드로 실행되는 행위의 모습이다. 예을 들어 서버와의 통신, 프로그래스바 등이 움직이는
행위를 연출할수 있다.
클라이언트와 서버와의 통신시에 자유롭게 마우스나 키보드나 행위를 할수 있어야 한다.
프로그래스바가 움직이는동안에서 마우스나 키보드나 행위를 할수 있어야 한다.
이런모습을 100에서 9999까지의 숫자중에 프라임넘버가 몇개인지 COUNT하는 TASK를 텍스트로 표현해보았다.
Console.WriteLine(">>>>>>Long running task start!!");
Console.WriteLine(">>>>>>Prime Number Cnt:[" + cnt.ToString("0000") + "]");
Console.WriteLine(">>>>>>Long running task end!!");
Console.WriteLine(">>>>>>Long running task completed!!");

3. 실제소스코드이다. 위를 표현한,ㅡㅡㅡㅡㅡ

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
 
namespace TrisPackage.Tris
{
    class Program
    {
        static void Main(string[] args)
        {
            BackgroundWorkerCls bwt = new BackgroundWorkerCls();
 
            while(true)
            {
                bwt.Execute();
            }
        }
    }
 
    class BackgroundWorkerCls
    {
        private BackgroundWorker worker;
 
        public BackgroundWorkerCls()
        {
            worker = new BackgroundWorker();
            worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
        }
        ~BackgroundWorkerCls()
        {
            worker.DoWork -= new DoWorkEventHandler(worker_DoWork);
        }
 
        public void Execute()
        {
            Console.Write("..");
 
            // InvalidOperationException Protection!!
            // InvalidOperationException Protection!!
            if(!worker.IsBusy) worker.RunWorkerAsync();
        }
 
        //Work Thread Execute Task Method
        //Work Thread Execute Task Method
        //Work Thread Execute Task Method
        void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            Console.WriteLine("");
            Console.WriteLine(">>>>>>Long running task start!!");

            int ii,kk,ff,prime,cnt=0;

            for(ii=100; ii < 9999; ii++)
            {
                prime = ii;
                ff = 0;
                for(kk=1; kk <= prime; kk++)
                {
                        if(prime / kk * kk == prime) ff++;
                }

                if(ff == 2) cnt++;
             }
             Console.WriteLine("");
             Console.WriteLine(">>>>>>Prime Number Cnt:[" + cnt.ToString("0000") + "]");
             Console.WriteLine("");
             Console.WriteLine(">>>>>>Long running task end!!");
             Console.WriteLine("");
        }

        //Work Thread Execute Task Method
        //Work Thread Execute Task Method
        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
                Console.WriteLine("");
                Console.WriteLine(">>>>>>Long running task completed!!");
                Console.WriteLine("");
        }
    }
}

 

결론적으로 위의 이미지에서 보이는 .....은 평상시에 우리가 화면을 핸들링하는 모습이고, 나머지의 메세지는 백그라운드를 통해서 이루어지는, 즉 비동기적으로 안보이는 작업들이 행해지는 모습을 나타낸것입니다.

[C언어] 변수 단위 파일 읽기 함수 - fscanf


※요약
fscanf : 개방된 파일에서 변수 단위로 입력을 받는다.

※특징
변수 간의 구분은 공백, 탭, 개행 문자로 한다.
*는 값을 읽지 않고 건너뛸 때 사용한다.
파일 포인터는 자동으로 증가한다.

※함수 원형 및 설명
int fscanf( FILE *stream, const char *format [, argument].. );
----- stream : 개방된 FILE 구조체의 포인터
----- format : 형식 제어 문자열
----- argument : 가변적인 매개변수
----- 반환값 : 읽혀진 필드의 수. 파일 끝 또는 에러 시 EOF(-1)

#include <stdio.h>

int main( )
{
FILE *pFile = NULL;

pFile = fopen( "d:\\Text.txt", "r" );
if( pFile == NULL )
{
//에러 처리
}
else
{
int nCount;
float fRatio;
char strDesc[255];

while( !feof( pFile ) )
{
//공백으로 분리된 파일 읽기
fscanf( pFile, "%d %f %s", &nCount, &fRatio, strDesc );
printf( "공백으로 분리 : %d %f %s\n", nCount, fRatio, strDesc );

//,로 분리된 파일 읽기
fscanf( pFile, "%d, %f, %s", &nCount, &fRatio, strDesc );
printf( ",로 분리 : %d, %f, %s\n", nCount, fRatio, strDesc );

//탭으로 분리된 파일 읽기
fscanf( pFile, "%d\t%f\t%s", &nCount, &fRatio, strDesc );
printf( "탭으로 분리 : %d\t%f\t%s\n", nCount, fRatio, strDesc );

//선별적으로 읽기 - [%*]을 사용하면 값을 읽지 않는다.
fscanf( pFile, "%*d %*f %s\n", strDesc );
printf( "선별적으로 읽기 : %s\n", strDesc );
}

fclose( pFile );
}

return 0;
}

C# 개요(Introduction)

C#은 C++의 컴퓨팅 파워와(1) 비주얼 베이직의 편리함(2)을 하나로 합치기 위해 마이크로소프트사(MS)에서 개발한 새로운 객체 지향 프로그래밍 언어입니다.

C#은 C++의 컴퓨팅 파워와 비주얼 베이직의 편리함을 하나로 합치기 위해 마이크로소프트사(MS)에서 개발한 새로운 객체 지향 프로그래밍 언어입니다.

C#은 C++의 컴퓨팅 파워와 비주얼 베이직의 편리함을 하나로 합치기 위해 마이크로소프트사(MS)에서 개발한 새로운 객체 지향 프로그래밍 언어입니다.

C#은 C++의 컴퓨팅 파워와 비주얼 베이직의 편리함을 하나로 합치기 위해 마이크로소프트사(MS)에서 개발한 새로운 객체 지향 프로그래밍 언어입니다.

C#은 C++의 컴퓨팅 파워와 비주얼 베이직의 편리함을 하나로 합치기 위해 마이크로소프트사(MS)에서 개발한 새로운 객체 지향 프로그래밍 언어입니다.

/*
C# 언어 대리자 개념은 최고 수준의 언어 지원 및 해당 개념 관련 형식 안정성을 제공합니다.
함수 포인터는 호출 규칙을 더욱 세부적으로 제어해야 하는 유사한 시나리오용으로 C# 9에 추가되었습니다. 
대리자와 연결된 코드는 대리자 형식에 추가된 가상 메서드를 사용하여 호출됩니다.
*/

/*----------------------------------------------------------------------------------
>>대리자

1.  ElapsedEventHandler 대리자
1.1 public delegate void ElapsedEventHandler(object sender, ElapsedEventArgs e);

>>대리자 호출

1.  Timer.Elapsed 이벤트
1.1 public event System.Timers.ElapsedEventHandler Elapsed;
----------------------------------------------------------------------------------*/


c# 객체지향 언어이긴 하지만 함수지향형 언어가 갖는 특징을 갖기도 합니다.
이를테면 c언어의 함수 포인터에 해당하는 기능이 c#에도 있다는 겁니다.
오히려, c언어의 함수포인터보다 기능이 더 강화되었습니다.

1. 대리자(Delegate)

c# 초기 버젼부터 있던 기능입니다. c언어의 함수포인터를 그대로 차용한거나 다름없습니다.
메소드의 위치를 간직하고 있으면서, 그 메서드를 실행해 주는 역할을 합니다.

Ex)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TEST
{
class Program
{
delegate void DelegateMethod(int a);

static void method1(int a){Console.WriteLine("method1 called!! a = {0}", ++a);}
static void method2(int a){Console.WriteLine("method2 called!! a = {0}", ++a);}
static void method3(int a){Console.WriteLine("method3 called!! a = {0}", ++a);}
static void method4(int a){Console.WriteLine("method4 called!! a = {0}", ++a);}
static void method5(int a){Console.WriteLine("method5 called!! a = {0}", ++a);}
static void method6(int a){Console.WriteLine("method6 called!! a = {0}", ++a);}
static void method7(int a){Console.WriteLine("method7 called!! a = {0}", ++a);}
static void method8(int a){Console.WriteLine("method8 called!! a = {0}", ++a);}
static void method9(int a){Console.WriteLine("method9 called!! a = {0}", ++a);}

static void Main()
{
DelegateMethod method = null;

method += method1;
method += method2;
method += method3;
method += method4;
method += method5;
method += method6;
method += method7;
method += method8;
method += method9;

method(0);
}
}
}


결과) 동시에 실행이 된다고 볼수 있다. a의 값을 주목

D:\tmp\console>sample.exe
method1 called!! a = 1
method2 called!! a = 1
method3 called!! a = 1
method4 called!! a = 1
method5 called!! a = 1
method6 called!! a = 1
method7 called!! a = 1
method8 called!! a = 1
method9 called!! a = 1
D:\tmp\console>

/*Handler
- DoWorkEventHandler
- RunWorkerCompletedEventHandler
*/
using System.ComponentModel

 

System.ComponentModel 네임스페이스

구성 요소와 컨트롤의 런타임 및 디자인 타임 동작을 구현하는 데 사용되는 클래스를 제공합니다. Provides classes that are used to implement the run-time and design-time behavior of components and controls. 이 네임스

docs.microsoft.com

class TrisCls
{
     int xpos,ypos;
     BackgroundWorker sendWork;

    public void running()
    {
        ConsoleKeyInfo keyinfo;

        init();
        while(true)
        {
            //add
        }
    }
    void init()
    {
        xpos=ypos=0;
       
        sendWorker = new BackgroundWorker();
        sendWorker.DoWork += new DoWorkEventHandler(sendWorker_DoWork);
        sendWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(sendWorker_RunWorkerCompleted);
    }
    void DoWorkEventHandler(object sender, DoWorkEventArgs e)
    {
         Console.WriteLine("DoWorkEventHandler>>" + xpos.ToString("0000") );
         xpos++;
    }
    void sendWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        Console.WriteLine("sendWorker_RunWorkerCompleted>>" + ypos.ToString("0000") );
        ypos++;
    }
}

int exchange_check()
{
int ii,kk,ff,tmp;
int[,] tristmp = new int[MAPY,MAPX];
int[,] designtmp = new int[ARR,ARR];

for(ii=0; ii<MAPY; ii++)
for(kk=0; kk<MAPX; kk++)
{
tristmp[ii,kk]=tris[ii,kk];
}

for(ii=0; ii<ARR; ii++)
for(kk=0; kk<ARR; kk++)
{
designtmp[ii,kk]=design[ii,kk];
}

for(ii=0; ii<ARR; ii++)
for(kk=0; kk<ARR; kk++)
{
if(ypos+ii>MAPY-1) continue;
if(xpos+kk>MAPX-1) continue;
if(xpos+kk<0) continue;

if(designtmp[ii,kk]==1) tristmp[ypos+ii,xpos+kk]=0;
}

//exchange//exchange//exchange//exchange//exchange
//exchange//exchange//exchange//exchange//exchange
//exchange//exchange//exchange//exchange//exchange
//exchange//exchange//exchange//exchange//exchange

/*
{0,0},{0,1},{0,2},{0,3},
{1,0},{1,1},{1,2},{1,3},
{2,0},{2,1},{2,2},{2,3},
{3,0},{3,1},{3,2},{3,3},
*/

for(ii=0; ii<3; ii++)
{
//add
}
tmp=designtmp[1,1];
designtmp[1,1]=designtmp[1,2];
designtmp[1,2]=designtmp[2,2];
designtmp[2,2]=designtmp[2,1];
designtmp[2,1]=tmp;

for(ii=0; ii<ARR; ii++)
for(kk=0; kk<ARR; kk++)
{
if(ypos+ii>MAPY-1) continue;
if(xpos+kk>MAPX-1) continue;
if(xpos+kk<0) continue;

if(designtmp[ii,kk]==1) tristmp[ypos+ii,xpos+kk] += 1;
}

ff=0;
for(ii=0; ii<ARR; ii++)
for(kk=0; kk<ARR; kk++)
{
if(ypos+ii>MAPY-1) continue;
if(xpos+kk>MAPX-1) continue;
if(xpos+kk<0) continue;

if(tristmp[ypos+ii,xpos+kk] > 1) ff++;
}

if(ff > 0)
{
return(FAIL);
}
else
{
for(ii=0; ii<MAPY; ii++)
for(kk=0; kk<MAPX; kk++)
{
tris[ii,kk]=tristmp[ii,kk];
}

for(ii=0; ii<ARR; ii++)
for(kk=0; kk<ARR; kk++)
{
design[ii,kk]=designtmp[ii,kk];
}
}
return(SUCC);
}

 

통합 개발 환경(Integrated Development Environment, IDE)이란 
공통된 개발자 툴을 하나의 그래픽 사용자 인터페이스(Graphical User Interface, GUI)로 
결합하는 애플리케이션을 구축하기 위한 소프트웨어입니다.

DELPHI IDE(sample)
- Language : Pascal

 

C# IDE = Visual Studio(Windows)
- Language : c#

IDE없이, notepad에서 코드를 작성한후에, 실행파일을 만들수도 있다.
IDE없이, notepad에서 코드를 작성한후에, 실행파일을 만들수도 있다.

C#

[요약] C++(시플러스플러스)에 기본을 두고, 비주얼베이직(visual basic)의 편의성을 결합하여 만든 객체지향 프로그래밍언어이다.

모든 것을 객체로 취급하는 컴포넌트 프로그래밍언어로, 시샵(C-sharp)이라고 발음한다. 2000년 6월 마이크로소프트가 닷넷(.NET) 폴랫폼을 위해 개발하였다. C++(시플러스플러스)에 기본을 둔 언어로, 비주얼베이직이나 자바(Java)와도 비슷하다. 따라서 비주얼베이직과 자바·C++ 등의 장점을 지닌다. 곧 비주얼 언어가 가진 사용자 친화성, C++의 객체지향성, 자바의 분산환경처리에 적합한 다중성 등을 모두 지니는 컴포넌트 기반의 소프트웨어 개발 패러다임을 반영한다.

웹을 통해 정보와 서비스를 교환하고, 개발자들이 이식성(portability) 높은 응용프로그램들을 만들어 낼 수 있게 고안되었다. 즉, 이 프로그래밍언어를 사용하면 대대적인 개정 없이도 하나 이상의 OS(운영체제)에서 사용될 수 있는 응용프로그램들을 만들어낼 수가 있다. 따라서 프로그래머가 별도의 코드를 만들지 않고서도 새로운 제품이나 서비스를 빠르고 값싸게 시장에 내놓을 수 있게 된다.

[네이버 지식백과] C# [C-sharp] (두산백과)

Added knowledge--------------------------------
Cross Platform
Whether you're working in C#, F#, or Visual Basic, your code will run natively on any compatible OS. Different 
.NET implementations handle the heavy lifting for you:

1) .NET is a cross-platform .NET implementation for websites, servers, and console apps on Windows, Linux, and macOS.
2) .NET Framework supports websites, services, desktop apps, and more on Windows.
3) Xamarin/Mono is a .NET implementation for running apps on all the major mobile operating systems.

'테트리스' 카테고리의 다른 글

C#, Tettris :: check_horizon routine()  (0) 2022.08.31
tris::common_chek(int direction)::final  (0) 2022.04.18
테트리스 개발코드관련  (0) 2021.04.16

/*TrisPackage.Tris/draw();*/

void draw()
{
    string formattext="";
    string succsign="{}";
    string failsign="..";
    int ii,kk,ff=0;

    now=DateTime.Now;
    ____draw(0,ref ff, "Time:[" + now.ToString("yyyy-MM-dd HH:mm:ss") + "]");
    for(ii=0; ii<MAPY-1; ii++)
    {
        for(kk=1; kk<MAPX-1; kk++)
        {
            if(tris[ ii,kk] == 1) formattext=formattext+succsign;
            else formattext=formattext+failsign;
        }
        ____draw(0,ref ff,formattext);
    }
    ____draw(0,ref ff,"Score:[" + score.ToString("00000000") + "]");
}
void ____draw(int x,ref int y, string str)
{
    try
    {
        Console.SetCursorPosition(x,y);
        y++;
        Console.Write(str);
    }
    catch(ArgumentOutOfRangeException e)
    {
        Console.WriteLine(e.Message);
    }
}
    
    

/*TrisPackage.Tris/running();*/

public void running()
{
    int rc;

    init();
    while(true)
    {
        keyinfo = Console.ReadKey(true);

        if(keyinfo.Key==ConsoleKey.RightArrow) rc=common_check(D_RIGHT);
        if(keyinfo.Key==ConsoleKey.LeftArrow) rc=common_check(D_LEFT);
        if(keyinfo.Key==ConsoleKey.Enter) rc=direct_check();
        if(keyinfo.Key==ConsoleKey.Escape) break;

        draw();
    }
    stop();
}

 

/*TrisPackage.Tris/check_horizon();*/

int check_horizon()
{
    int ii,kk,ff;

    for(ii=0; ii<MAPY-1; ii++)
    {
        ff=0;
        for(kk=1; kk<MAPX-2; kk++)
        {
            if(tris[ii, kk] != 0)
            {
                if(tris[ii, kk] == tris[ii, kk + 1]) ff++;
                else break;
            }
        }
        if(ff == MAPX-3)
        {
            for(kk=1; kk<MAPX-1; kk++) delete_column(ii,kk);

            score++;
            return(SUCC); 
        }
    }
    //NOT FOUND,Then FAIL!!
    //NOT FOUND,Then FAIL!!
    return(FAIL); 

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/draw();____draw();  (0) 2021.11.19
TrisPackage.Tris/running();  (0) 2021.11.19
TrisPackage.Tris/delete_column();  (0) 2021.11.19
TrisPackage.Tris/definition/variables/controls  (0) 2021.11.17
TrisPackage.Tris/common_check();  (0) 2021.11.17

/*TrisPackage.Tris/delete_column();*/

void delete_column(int y, int x)
{
    int ii;

    for(ii=y; ii >= 1; ii--)
    {
        tris[ii, x] = tris[ii-1, x];
    }
}

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/running();  (0) 2021.11.19
TrisPackage.Tris/check_horizon();  (0) 2021.11.19
TrisPackage.Tris/definition/variables/controls  (0) 2021.11.17
TrisPackage.Tris/common_check();  (0) 2021.11.17
TrisPackage.Tris/check_horizon();  (0) 2021.11.17

/*TrisPackage.Tris/definition/variables/controls*/
class TrisCls
{
    //definition
    const int MAPY=22; //final int MAPY=22; //#define MAPY 22
    const int MAPX=31;
    //variables
    int[,] tris = new int[MAPY,MAPX]; //int[][] tris = new int[MAPY][MAPX]; //int tris[MAPY][MAPX];
    //controls
    Timer tm; //class
    Random rr; //class
    ConsoleKeyInfo keyinfo; //structure
    DateTime now; //structure
    //method
    public void running()
    {
        //add code
    }
}

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/check_horizon();  (0) 2021.11.19
TrisPackage.Tris/delete_column();  (0) 2021.11.19
TrisPackage.Tris/common_check();  (0) 2021.11.17
TrisPackage.Tris/check_horizon();  (0) 2021.11.17
TrisPackage.Tris/tris_time_tick();  (0) 2021.11.17

int common_check(int direction)
{
    int ii,kk,ff;
    int[,] tristmp = new int[MAPY,MAPX];

    for(ii=0; ii<MAPY; ii++)
    for(kk=0; kk<MAPX; kk++)
    {
        tristmp[ii,kk]=tris[ii,kk]; }

    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        //Index Array Exception//Index Array Exception//Index Array Exception
        if(ypos+ii >MAPY-1) continue;

        if(xpos+kk > MAX-1) continue;
        if(xpos+kk < 0) continue;

        if(design[ii,kk]==1) tristmp[ypos+ii,xpos+kk]=0; }

    if(direction==D_RIGHT) xpos++;
    if(direction==D_LEFT) xpos--;
    if(direction==D_DOWN) ypos++;

    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        //Index Array Exception//Index Array Exception//Index Array Exception

        if(ypos+ii >MAPY-1) continue;
         if(xpos+kk > MAX-1) continue;
         if(xpos+kk < 0) continue;


        if(design[ii,kk]==1) tristmp[ypos+ii,xpos+kk] += 1; }

    ff=0;
    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        //Index Array Exception//Index Array Exception//Index Array Exception
        if(ypos+ii >MAPY-1) continue;

        if(xpos+kk > MAX-1) continue;
        if(xpos+kk < 0) continue;

        if(tristmp[ypos+ii,xpos+kk] > 1) ff++;
    }
    if(ff>0)
    {
        if(direction==D_RIGHT) xpos--;
        if(direction==D_LEFT) xpos++;
        if(direction==D_DOWN) ypos--;

        return(FAIL);
    }
    else
    {
        for(ii=0; ii<MAPY; ii++)
        for(kk=0; kk<MAPX; kk++)
        { tris[ii,kk]=tristmp[ii,kk] }
    }
    return(SUCC);
}

Ex)
void tris_time_tick(object sender, ElapsedEventArgs e)
{
    int rc;

    draw();
    rc= common_check(D_DOWN);
    if(rc == FAIL) 
    {
        if(ypos== 0) stop();
        else
        {
            while(true)
            {
                if(check_horizon()==FAIL) break;
            }
            ____init("L");
        }
    }
}

 

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/delete_column();  (0) 2021.11.19
TrisPackage.Tris/definition/variables/controls  (0) 2021.11.17
TrisPackage.Tris/check_horizon();  (0) 2021.11.17
TrisPackage.Tris/tris_time_tick();  (0) 2021.11.17
TrisPackage.Tris/direct_check();  (0) 2021.11.17

int check_horizon()
{
    int ii,kk,ff;
    for(ii=0; ii<MAPY-1; ii++)
    {
        ff=0;
        for(kk=1; kk<MAPX-2; kk++)
        {
            if(tris[ii,kk] != 0)
            {
                if(tris[ii,kk] == tris[ii,kk+1]) ff++;
                else break;
            }
        }
        if(ff==MAPX-3)
        {
            for(kk=1; kk<MAPX-1; kk++) delete_column(ii,kk);
            score++;
            return(SUCC);
        }
    }
    return(FAIL);
}

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/definition/variables/controls  (0) 2021.11.17
TrisPackage.Tris/common_check();  (0) 2021.11.17
TrisPackage.Tris/tris_time_tick();  (0) 2021.11.17
TrisPackage.Tris/direct_check();  (0) 2021.11.17
TrisPackage.Tris/common_init();  (0) 2021.11.17

void tris_time_tick(object sender, ElapsedEventArgs e)
{
    int rc;   
    draw();
    rc=common_check(D_DOWN);
    if(rc==FAIL)
    {
        if(ypos==0) stop();
        else
        {
            while(true)
            {
                if(check_horizon()==FAIL) break;
            }
            common_init(FAIL);
        }
    }
}

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/common_check();  (0) 2021.11.17
TrisPackage.Tris/check_horizon();  (0) 2021.11.17
TrisPackage.Tris/direct_check();  (0) 2021.11.17
TrisPackage.Tris/common_init();  (0) 2021.11.17
time_tick - keyboard hit(Auto)  (0) 2021.11.16

int direct_check()
{
    while(true)
    {
        if(common_check(D_DOWN)==FAIL) break;
        draw();
    }
    while(true)
    {
        if(check_horizon()==FAIL) break;
    }
    common_init(FAIL);
    return(SUCC);
}

'c# 언어' 카테고리의 다른 글

TrisPackage.Tris/check_horizon();  (0) 2021.11.17
TrisPackage.Tris/tris_time_tick();  (0) 2021.11.17
TrisPackage.Tris/common_init();  (0) 2021.11.17
time_tick - keyboard hit(Auto)  (0) 2021.11.16
Console.SetCursorPosition Method try & catch  (0) 2021.11.11

void common_init(int idx)
{
    int ii,kk;
    if(idx==SUCC)
    {
        score=0;
        hyun=rr.Next() % MAXDESIGN;
        next=rr.Next() % MAXDESIGN;
    }
    else if(idx==FAIL)
    {
        hyun=next;
        next=rr.Next() % MAXDESIGN;
    }
    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        design[ii,kk]=realdesign[hyun,ii,kk];
        tris[ypos+ii,xpos+kk]=design[ii,kk];
    }
}

/*time_tick - keyboard hit(Auto)*/
/*time_tick - keyboard hit(Auto)*/
/*time_tick - keyboard hit(Auto)*/

using System;
using System.IO;
using System.Timers;
using System.Threading;
using System.Runtime.InteropServices; //DLL Import

namespace ConsoleNoLogin
{
class Program
{
[DllImport("user32.dll")]
public static extern void keybd_event(byte vk, byte scan, int flags, ref int extrainfo);

static System.Timers.Timer timer1;
static System.Timers.Timer timer2;

static int index1=0;
static int index2=0;

static int ____minus=0;

const byte EscKey=27;
const int KEY_UP=0x0002;

const int REMAINED_TIME=60000;
const int SECOND_USER_DEFINE=1000;

static void Main(string[] args)
{
int toggle=0;

timer1 = new System.Timers.Timer();
timer2 = new System.Timers.Timer();

timer1.Interval = REMAINED_TIME;
timer2.Interval = SECOND_USER_DEFINE;

timer1.Elapsed += new ElapsedEventHandler(__tick_time_1);
timer2.Elapsed += new ElapsedEventHandler(__tick_time_2);

timer1.Start();
timer2.Start();

ConsoleKey key = ConsoleKey.NoName;

Logging("Start Timer");
while(true)
{
key=Console.ReadKey(true).Key;
if(key==ConsoleKey.Enter)
{
if(toggle==0)
{
timer1.Stop();
timer2.Stop();

toggle=100;

Logging("Stop Timer");
}
else
{
Logging("Start Timer");

index1=0;
index2=0;

timer1.Start();
timer2.Start();

toggle=0;
}
}
else
if(key==ConsoleKey.Spacebar)
{
timer1.Stop();
timer2.Stop();

break;
}
}

timer1.Elapsed -= __tick_time_1;
timer2.Elapsed -= __tick_time_2;
}

static void __tick_time_1(object sender, ElapsedEventArgs e)
{
int info=0;

index2=0;
index1++;

if(index1 == 100) index1=0;

Logging("MAIN(KEYBOARD HIT)");

keybd_event(EscKey,0,0,ref info);
Thread.Sleep(10);
keybd_event(EscKey,0,KEY_UP,ref info);
}

static void __tick_time_2(object sender, ElapsedEventArgs e)
{
index2++;
____minus=REMAINED_TIME/SECOND_USER_DEFINE-index2;

Logging("SUB ");
}

static void Logging(string msg)
{
DateTime now = DateTime.Now;

if(msg=="Start Timer")
{
Console.WriteLine(">>>>[Start Timer]" + "    " + now.ToString("yyyy-MM-dd hh:mm:ss"));
Console.Title = ">>>>[Start Timer]" + "    " + now.ToString("yyyy-MM-dd hh:mm:ss");
}
else if(msg=="Stop Timer")
{
Console.WriteLine(">>>>[Stop Timer]" + "    " + now.ToString("yyyy-MM-dd hh:mm:ss"));
Console.Title = ">>>>[Stop Timer]" + "    " + now.ToString("yyyy-MM-dd hh:mm:ss");
}
else
{
Console.WriteLine(msg + ">>>>" + "    " + now.ToString("yyyy-MM-dd hh:mm:ss"));
Console.Title = msg + ">>>>" + "    " + now.ToString("yyyy-MM-dd hh:mm:ss");
}
}
}//end of class
}//end of namespace








/*C언어 기초 - 쓰레드 이해하고 사용하는 방법(windows 10)*/
/*C언어 기초 - 쓰레드 이해하고 사용하는 방법(windows 10)*/
/*C언어 기초 - 쓰레드 이해하고 사용하는 방법(windows 10)*/

#include <stdio.h>
#include <Windows.h>
#include <process.h>

unsigned _stdcall time_tick(void* arg)
{
while(1)
{
Sleep(1000);

draw();
rc=common_check(D_DOWN);
if(rc==FAIL)
{
if(ypos==0)
{
return(FAIL);
}
else
{
while(1)
{
if(check_horizon()==FAIL) break;
}
xpos=MAPX/2;
ypos=0;

//,,
//,,
}
}
}
return(SUCC);
}

void init()
{
_beginthreadex(NULL, 0, time_tick, 0, 0, NULL);
}

void stop()
{}

void main(void)
{
init();
while (1)
{
//,,
//,,
}
stop();
}

>c_tris90_4_4.c 
>gcc -c c_tris90_4_4.c
>gcc -o c_tris90_4_4 c_tris90_4_4.o -lm -lws2_32 -lgdi32

c_tris90_4_4.c
0.01MB

+ Recent posts