main.cpp

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

#define logow 40
#define logoh 10

#define LX 8
#define LY 16
#define SFONT "Courier New"
#define ACTORS_VELOCITY 20

#define COLOR_ACTOR 0xB0FFB0
#define COLOR_MATRIXMAXR 0x00
#define COLOR_MATRIXMAXG 0xFF
#define COLOR_MATRIXMAXB 0x00
#define COLOR_MATRIXMINR 0x00
#define COLOR_MATRIXMING 0x00
#define COLOR_MATRIXMINB 0x00

#define COLOR_LOGO 0x00FF00
#define COLOR_LOGO_EDGE 0x00FFFF
#define COLOR_LOGO_TITLE 0xB0FFB0

#define SYMBOL_0 '0'
#define SYMBOL_1 '1'

#define ERROR_TITLE "Îøèáêà"
#define ERROR_CANTREGISTERClASS "Íå óäàëîñü çàðåãèñòðèðîâàòü êëàññ îêíà"
#define ERROR_CANTCREATEWINDOW "Íå óäàëîñü ñîçäàòü îêíî"


HINSTANCE hInstance;
int w, h;
int ws, hs, xs, ys;


int Random(int from, int to){
	return rand() % (to-from+1) + from;
}


class Window{
protected:
	HWND hWnd;

private:
	int RegisterClass(){
		LOGBRUSH lb;
		lb.lbColor = 0x000000;
		lb.lbStyle = BS_SOLID;
		lb.lbHatch = NULL;
		HBRUSH brush = CreateBrushIndirect(&lb);

		WNDCLASSEX wcex;

		wcex.cbSize			= sizeof(WNDCLASSEX);
		wcex.style			= CS_HREDRAW | CS_VREDRAW;
		wcex.lpfnWndProc	= (WNDPROC)WindowProc;
		wcex.cbClsExtra		= 0;
		wcex.cbWndExtra		= 0;
		wcex.hInstance		= hInstance;
		wcex.hIcon			= NULL;
		wcex.hIconSm		= NULL;
		wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
		wcex.hbrBackground	= brush;
		wcex.lpszMenuName	= NULL;
		wcex.lpszClassName	= "MySSWindow";

		return RegisterClassEx(&wcex);
	}

	int Create(Window *pobj){
		hWnd = CreateWindow("MySSWindow", "ScreenSaver", WS_POPUP, 0, 0, w, h, NULL, NULL, hInstance, pobj);
		if(!hWnd) return FALSE;

		ShowWindow(hWnd, SW_SHOWMAXIMIZED);
		UpdateWindow(hWnd);

		return TRUE;
	}

	LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
		PAINTSTRUCT ps;
		HDC hdc;

		Window *pWindow;
		pWindow = (Window *)GetWindowLong(hWnd, GWL_USERDATA);

		switch(uMsg){
			case WM_TIMER:
				pWindow->OnTimer();
				break;
			case WM_PAINT:
				hdc = BeginPaint(hWnd, &ps);
				pWindow->OnDraw(hdc);
				EndPaint(hWnd, &ps);
				break;
			case WM_KEYDOWN:
				pWindow->OnKeyUp(wParam);
				break;
			case WM_DESTROY:
				pWindow->OnDestroy();
				PostQuitMessage(0);
				break;
			default:
				return DefWindowProc(hWnd, uMsg, wParam, lParam);
		}

		return 0;
	}

public:
	Window(){
		if(!RegisterClass()){
			MessageBox(0, ERROR_CANTREGISTERClASS, ERROR_TITLE, MB_ICONERROR);
			ExitProcess(0);
		}
	}

	void Init(Window *pobj){
		if(!Create(pobj)){
			MessageBox(0, ERROR_CANTCREATEWINDOW, ERROR_TITLE, MB_ICONERROR);
			ExitProcess(0);
		}
		MainLoop();
	}

	int MainLoop(){
		MSG msg;

		while(GetMessage(&msg, NULL, 0, 0)){
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		return (int)msg.wParam;
	}

	static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam){
		if(uMsg == WM_NCCREATE) SetWindowLong(hwnd, GWL_USERDATA, (LONG)((LPCREATESTRUCT)lParam)->lpCreateParams);

		Window *pWindow;
		pWindow = (Window *)GetWindowLong(hwnd, GWL_USERDATA);

		return pWindow->WndProc(hwnd, uMsg, wParam, lParam);
    }

	virtual void OnKeyUp(WPARAM KeyCode){}
	virtual void OnDraw(HDC hDC){}
	virtual void OnTimer(){}
	virtual void OnDestroy(){}
};


class Symbols{
private:
	char *pSymbols, *oldpSymbols;
	int *pColors, *oldpColors;

public:
	Symbols(){
		pSymbols = new char [ws*hs];
		oldpSymbols = new char [ws*hs];
		pColors = new int [ws*hs];
		oldpColors = new int [ws*hs];

		for(int i=0; i<ws; i++){
			for(int j=0; j<hs; j++){
				pSymbols[j*ws+i] = ' ';
				pColors[j*ws+i] = (COLOR_MATRIXMAXB<<16)+(COLOR_MATRIXMAXG<<8)+COLOR_MATRIXMAXR;
				oldpSymbols[j*ws+i] = '\0';
				oldpColors[j*ws+i] = 0;
			}
		}
	}

	char forcegetSymbol(int x, int y){

		if(x<0 || x>=ws || y<0 || y>=hs) MessageBox(0, "forcegetSymbol leak!", "err", MB_ICONERROR);

		return pSymbols[y*ws+x];
	}

	char getSymbol(int x, int y){

		if(x<0 || x>=ws || y<0 || y>=hs) MessageBox(0, "getSymbol leak!", "err", MB_ICONERROR);

		if(pSymbols[y*ws+x] != oldpSymbols[y*ws+x] || pColors[y*ws+x] != oldpColors[y*ws+x]){
			oldpSymbols[y*ws+x] = pSymbols[y*ws+x];
			oldpColors[y*ws+x] = pColors[y*ws+x];
			return pSymbols[y*ws+x];
		}
		return 0;
	}

	int getColor(int x, int y){

		if(x<0 || x>=ws || y<0 || y>=hs) MessageBox(0, "getColor leak!", "err", MB_ICONERROR);

		return pColors[y*ws+x];
	}

	void setActorTrack(int x, int y, int c){

		if(x<0 || x>=ws || y<0 || y>hs || c<0 || c>1) MessageBox(0, "setActorTrack leak!", "err", MB_ICONERROR);

		unsigned int rc, r, g, b;
		int nn = Random(0, 1)?SYMBOL_0:SYMBOL_1;
		if(c == 1){
			if(y < hs){
				pSymbols[y*ws+x] = nn;
				pColors[y*ws+x] = COLOR_ACTOR;
			}
			if(y>0){
				pSymbols[(y-1)*ws+x] = nn;
				rc = Random(1, 255);
				r = (COLOR_MATRIXMAXR-COLOR_MATRIXMINR)*rc/255+COLOR_MATRIXMINR;
				g = (COLOR_MATRIXMAXG-COLOR_MATRIXMING)*rc/255+COLOR_MATRIXMING;
				b = (COLOR_MATRIXMAXB-COLOR_MATRIXMINB)*rc/255+COLOR_MATRIXMINB;
				pColors[(y-1)*ws+x] = (b<<16)+(g<<8)+r;
			}
		} else{
			if(y < hs) pSymbols[y*ws+x] = ' ';
		}
	}
};


class Actors{
private:
	struct tagActor{
		int pos;
		int col;
	} *pActors;

public:
	Actors(){
		pActors = new tagActor [ws];
		for(int i=0; i<ws; i++){
			pActors[i].pos = -1;
			pActors[i].col = -1;
		}
	}

	int getPosition(int nActor){

		if(nActor<0 || nActor>=ws) MessageBox(0, "getPosition leak!", "err", MB_ICONERROR);

		return pActors[nActor].pos;
	}

	int getType(int nActor){

		if(nActor<0 || nActor>=ws) MessageBox(0, "getType leak!", "err", MB_ICONERROR);

		return pActors[nActor].col;
	}

	void NextStep(){
		int i;
		for(i=0; i<ws; i++){
			if(pActors[i].pos >= 0) pActors[i].pos++;
			if(pActors[i].pos > hs) pActors[i].pos = -1;
		}
	}

	void SelectRndActor(){
		int h;

		do{
			h = Random(0, ws-1);

			if(h<0 || h>=ws) MessageBox(0, "SelectRndActor leak!", "err", MB_ICONERROR);

		} while(pActors[h].pos != -1);

		pActors[h].pos = 0;
		pActors[h].col = (Random(1, 5) != 5);
	}
};


class MatrixHY{
private:
	Actors *pActors;
	Symbols *pSymbols;

	enum tagState{
		LOGO_HIDE, LOGO_SHOW, TEXT_SHOW
	} State;

public:
	MatrixHY(){
		State = LOGO_HIDE;
		pActors = new Actors;
		pSymbols = new Symbols;
	}

	void ReCalculate(){
		if(State == TEXT_SHOW){

		} else{
			pActors->SelectRndActor();

			for(int i=0; i<ws; i++){
				if(pActors->getPosition(i) >= 0) pSymbols->setActorTrack(i, pActors->getPosition(i), pActors->getType(i));
			}
			pActors->NextStep();
		}
	}

	void ToggleState(){
		State = (State == LOGO_HIDE)?LOGO_SHOW:LOGO_HIDE;
	}

	unsigned int getColor(int x, int y){
		if(State == LOGO_SHOW && x>=xs && x<xs+logow && y>=ys && y<ys+logoh){
			if(y == ys || x == xs || x == xs+logow-1 || y == ys+logoh-1) return COLOR_LOGO_EDGE;
			if(y == ys+1) return COLOR_LOGO_TITLE;
			else return COLOR_LOGO;
		}
		return pSymbols->getColor(x, y);
	}

	char getSymbol(int x, int y){
		static char buff[10][43] ={	"+--------------------------------------+\n",
									"| 'Matrix has you' screensaver v. 2.00 |\n",
									"|                                      |\n",
									"|   + new font                         |\n",
									"|   + this 'About...'                  |\n",
									"|   + Stuff have been deleted          |\n",
									"|   + rewrited on C++                  |\n",
									"|  Have fun!                           |\n",
									"|                       © SharpC, 2005 |\n",
									"+--------------------------------------+\n"};
		if(x>=xs && x<xs+logow && y>=ys && y<ys+logoh){

			if(y-ys<0 || y-ys>=logoh || x-xs<0 || x-xs>=logow) MessageBox(0, "SelectRndActor leak!", "err", MB_ICONERROR);

			if(State == LOGO_SHOW) return buff[y-ys][x-xs];
			else return pSymbols->forcegetSymbol(x, y);
		}
		return pSymbols->getSymbol(x, y);
	}
};


class MySSWindow: public Window{
private:
	MatrixHY *pMatrix;

	UINT_PTR timerId;
	UINT_PTR nTimer1;
	HFONT hFont;

	void DrawBorder(HDC hDC){
		int x1, y1, x2, y2;

		x1 = xs*LX+LX/2;
		y1 = ys*LY+LY/2-3;
		x2 = (xs+logow)*LX-LX/2;
		y2 = (ys+logoh)*LY-LY/2+3;

		MoveToEx(hDC, x1, y1, NULL);
		LineTo(hDC, x2, y1);
		LineTo(hDC, x2, y2);
		LineTo(hDC, x1, y2);
		LineTo(hDC, x1, y1);

		x1+=3; y1+=3; x2-=3; y2-=3;
		MoveToEx(hDC, x1, y1, NULL);
		LineTo(hDC, x2, y1);
		LineTo(hDC, x2, y2);
		LineTo(hDC, x1, y2);
		LineTo(hDC, x1, y1);
	}

public:
	MySSWindow(){
		pMatrix = new MatrixHY;
		Init(this);
	}

	void OnCreate(){
		timerId = 0;
		nTimer1 = 1;
		if(!timerId) timerId = SetTimer(hWnd, nTimer1, ACTORS_VELOCITY, NULL);
		hFont = CreateFont(LY, LX, 0, 0, 400, 0, 0, 0, \
			RUSSIAN_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, \
			DEFAULT_QUALITY, DEFAULT_PITCH | FF_SCRIPT, SFONT);
		char buff[128];
		//wsprintf(buff, "hFont = %d", hFont);
		//MessageBox(0, buff, "hFont", MB_ICONASTERISK);
		//SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, TRUE);
		//SelectObject(GetDC(hWnd), hFont);
	}

	void OnDestroy(){
		KillTimer(hWnd, nTimer1);
		DeleteObject(hFont);
	}

	void OnKeyUp(WPARAM KeyCode){
		switch(KeyCode){
			case 0x41:
				pMatrix->ToggleState();
				RECT wr;
				wr.left = xs*LX;
				wr.top = ys*LY;
				wr.right = (xs+logow)*LX;
				wr.bottom = (ys+logoh)*LY;
				InvalidateRect(hWnd, &wr, 1);
				break;
			case VK_ESCAPE:
				ExitProcess(0);
				break;
		}
	}

	void OnDraw(HDC hDC){
		static int firstCall = 0;
		if(!firstCall){
			firstCall = 1;
			OnCreate();
		}

		RECT r;
		HPEN hPen;

		SelectObject(hDC, hFont);
		SetBkColor(hDC, (COLORREF)0x000000);

		char b[2]=" ";
		unsigned int c;
		for(int i=0; i<ws; i++){
			for(int j=0; j<hs; j++){
				if(b[0] = pMatrix->getSymbol(i, j)){
					c = pMatrix->getColor(i, j);
					if(c) SetTextColor(hDC, (COLORREF)c);
					r.left = i*LX; r.top = j*LY; r.right = (i+1)*LX; r.bottom = (j+1)*LY;
					DrawText(hDC, b, 1, &r, 0);
				}
			}
		}

	}

	void OnTimer(){
		pMatrix->ReCalculate();
		OnDraw(GetDC(hWnd));
	}
};



int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR sCmdLine, int nCmdShow){
	hInstance = hInst;

	w = GetSystemMetrics(SM_CXSCREEN);
	h = GetSystemMetrics(SM_CYSCREEN);

	ws = w/LX;
	hs = h/LY;

	xs=(ws-logow)/2;
	ys=(hs-logoh)/2;

	srand(GetTickCount());

	MySSWindow MyWindow;
	ExitProcess(0);
}