StarDestroyer.Net BBS

Code: Select all

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include "windows.h"

class AGradient {
    // ASCII gradient class
    
    std::string g; // The letter gradient to be used
    public:
        AGradient() {
            g = "MWYASQPDBNZOUVCXTFRJLI890657432mwyaspqdbnzouvcxtfrj1li\\/!:;"*_~-¨^,.'`´ ";
        }
        char GetChar(unsigned char n) {
            // Returns a matching letter, scaled over the gradient's size
            float f = float(n) / 256.f;
            int i = int(float(g.size()) * f);
            return g[i];
        }
};

class CBitmap {
    // Class for loading bitmaps
    bool loaded;
    std::string name;
    unsigned char *data;
    int width,height;
    int BPP;
    
    public:
        CBitmap() {
            loaded = false;
            data = NULL;
            width = height = BPP = 0;
        }
        ~CBitmap() {
            delete [] data;
        }
        bool Load(std::string filename);
        void Convert();
};

using namespace std;

/////////////////////////////////////////////////
// Class CBitmap

bool CBitmap::Load(string filename)
{
    // Loads a bitmap into memory
    if (loaded==true) // This bitmap is already loaded!
       return false;

    name = filename;

    // Create a temporary, all lower-case filename
    string lName = name;
    int (*pf)(int)=tolower; 
    transform(lName.begin(),lName.end(), lName.begin(), pf); 

    int imageSize=0;	// Used to store the image size when setting aside ram
    int bytesPerPixel=0;	// Holds number of bytes per pixel used in the file

    if (lName.find(".bmp")!=string::npos) // Load a .bmp file
    {
	    // These are both defined in Windows.h
	    BITMAPFILEHEADER	BitmapFileHeader;
	    BITMAPINFOHEADER	BitmapInfoHeader;

	    // open filename in "read binary" mode
	    FILE *file = fopen(filename.c_str(), "rb");
	    if (file == NULL) {
		    return false;
	    }

	    // Header
	    fread (&BitmapFileHeader, sizeof (BITMAPFILEHEADER), 1, file);
	    if (BitmapFileHeader.bfType != 'MB') {
		    fclose (file);
		    return false;
	    }
	    
	    // Information
	    fread (&BitmapInfoHeader, 1, sizeof (BITMAPINFOHEADER), file);
	    if (BitmapInfoHeader.biWidth==0 || BitmapInfoHeader.biHeight==0) {
		    fclose (file);
		    return false;
	    }
      
	    width = BitmapInfoHeader.biWidth;
	    height = BitmapInfoHeader.biHeight;
	    BPP = 3;	// Only load 24-bit Bitmaps
	    bytesPerPixel = 3;
	    imageSize = width*height*bytesPerPixel; // Set image size

        // Seek position in file (no headers in the data, please!)
	    fseek (file, BitmapFileHeader.bfOffBits, SEEK_SET);
	    data = new unsigned char [imageSize];
	    if (data == NULL) { // Error allocating memory!
		    delete [] data;
		    fclose (file);
		    return false; // Oh noes!
	    }
	    fread (data, 1, imageSize, file); // Read the file into memory

	    // Turn BGR to RBG
	    for (int i = 0; i < (int) imageSize; i += 3) {
		    int temp = data [i];
		    data [i + 0] = data [i + 2];
		    data [i + 2] = temp;
	    }

	    fclose(file); // Close file
    } else if (lName.find(".tga")!=string::npos) // Load a .tga file
    {
     	unsigned char		TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0};	// Uncompressed TGA Header
     	unsigned char		TGAcompare[12];	// Used To Compare TGA Header
     	unsigned char		header[6];	// First 6 Useful Bytes From The Header

     	FILE *file = fopen(filename.c_str(), "rb");	// Open The TGA File

     	if(	file==NULL ||		// Does File Even Exist?
       		fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) ||	// Are There 12 Bytes To Read?
       		memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0 ||	// Does The Header Match What We Want?
       		fread(header,1,sizeof(header),file)!=sizeof(header))	// If So Read Next 6 Header Bytes
     	{
     		if (file == NULL)	// Did The File Not Exist?
     			return false;	// Return False
     		else	// Otherwise
     		{
     			fclose(file);	// If Anything Failed, Close The File
     			return false;	// Return False
     		}
     	}

        // If went OK, so continue the loading
     	width  = header[1] * 256 + header[0];	// Determine The TGA Width
     	height = header[3] * 256 + header[2];	// Determine The TGA Height

    	if(	width	<=0	||	// Is The Width Less Than Or Equal To Zero
     		height	<=0	||	// Is The Height Less Than Or Equal To Zero
     		(header[4]!=24 && header[4]!=32))	// Is The TGA 24 or 32 Bit?
     	{
     		fclose(file);	// If Anything Failed, Close The File
     		return false;	// Return error
     	}

     	BPP = header[4]/8;		// Grab The TGA's Bits Per Pixel (24 or 32)
     	bytesPerPixel = BPP;	// Divide By 8 To Get The Bytes Per Pixel
     	imageSize = width*height*bytesPerPixel;	// Calculate The Memory Required For The TGA Data

     	data = new unsigned char[imageSize];	// Reserve Memory To Hold The TGA Data

     	if(	data==NULL ||	// Does The Storage Memory Exist?
     		fread(data, 1, imageSize, file)!=imageSize)	// Does The Image Size Match The Memory Reserved?
     	{
     		if(data!=NULL)
     			delete [] data;

     		fclose(file);	// Close The File
     		return false;
     	}

     	for(int i=0; i<int(imageSize); i+=bytesPerPixel)	// Loop Through The Image Data
     	{	// Swaps The 1st And 3rd Bytes (Red and Blue)
     		int temp=data[i];
     		data[i] = data[i + 2];
     		data[i + 2] = temp;
     	}

     	fclose (file);	// Close The File
    } else { // Unknown file format
        return false;
    }

    loaded = true; // Bitmap is now loaded. Hooray!

    return true; // Everything went OK
}

void CBitmap::Convert() {
    // Converts an image to text using the color information to produce a gradient
    if (loaded == false) return;
    
    int sizeX = 8;
    int sizeY = 15;
    
    int tWidth = width/sizeX;
    int tHeight = height/sizeY;
    int size = tWidth*tHeight*3;
    if (size == 0) return;
    unsigned char *cData = new unsigned char[size];
    
    // Downsample the image using sizeX*sizeY blocks
    for (int y=0, fx=0; y<tHeight && fx<size; ++y) {
        for (int x=0; x<tWidth && fx<size; ++x, fx+=3) {
            int r = 0,b = 0,g = 0;
            for (int dx=0; dx<sizeX; ++dx) {
                for (int dy=0; dy<sizeY; ++dy) {
                    if (x*sizeX + dx >= width || y*sizeY + dy >= height) break;
                    int p = (x*sizeX + dx) * BPP + (y*sizeY + dy) * width * BPP;
                    r += data[p];
                    g += data[p+1];
                    b += data[p+2];
                }
            }
            int d = sizeX*sizeY; // Average and store the colour
            r /= d; g /= d; b /= d;
            cData[fx] = (unsigned char)(r);
            cData[fx+1] = (unsigned char)(g);
            cData[fx+2] = (unsigned char)(b);
        }
    }
    
    // Convert the downsampled image to a "text gradient"
    AGradient grad;
    string str;
    for (int y=tHeight-1; y>=0; --y) { // Image is upside down...
        for (int x=0; x<tWidth; ++x) {
            int p = (x+y*tWidth)*3;
            
            int r = cData[p];
            int g = cData[p+1];
            int b = cData[p+2];
            int l = (r + g + b) / 3;
            
            str += grad.GetChar((unsigned char)(l));
        }
        str += "\n";
    }

    { // Write a text file
        int index = name.rfind(".");
        string filename(name,0,index);
        filename += ".txt";
        ofstream file(filename.c_str());
        file << str;
        file.close();
    }

    { // Write a bitmap using GDI text stuff
        int index = name.rfind(".");
        string filename(name,0,index);
        filename += "_t.bmp";
        
        // Create a device context in memory
        HDC hdc = CreateCompatibleDC(NULL);

        // Apply a bitmap
        BITMAPINFO bi;
        ZeroMemory( &bi.bmiHeader, sizeof(BITMAPINFOHEADER) );
        bi.bmiHeader.biWidth=tWidth*sizeX;
        bi.bmiHeader.biHeight=tHeight*sizeY;
        bi.bmiHeader.biPlanes=1;
        bi.bmiHeader.biBitCount=24;
        bi.bmiHeader.biSizeImage=0;
        bi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
        bi.bmiHeader.biClrUsed= 0;
        bi.bmiHeader.biClrImportant= 0;
        VOID *pvBits;
        HBITMAP hbmp= CreateDIBSection( hdc,
            &bi,
            DIB_RGB_COLORS,
            &pvBits,
            NULL,
            0);
        SelectObject(hdc,hbmp);

        // Create font
        HFONT font = CreateFont(sizeY,0,0,0,FW_NORMAL,FALSE,FALSE,0,ANSI_CHARSET,
           OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH | FF_SWISS,
           "Fixedsys");
        
        // Select font and set colours etc.
        SelectObject(hdc,font);
        SetBkMode(hdc,OPAQUE);
        SetBkColor(hdc,RGB(192,192,192));
        
        // Write coloured letters
        for (int y=0; y<tHeight; ++y) {
            for (int x=0; x<tWidth; ++x) {
                int p = (x+(tHeight-y-1)*tWidth)*3;
            
                int r = cData[p];
                int g = cData[p+1];
                int b = cData[p+2];
                SetTextColor(hdc,RGB(r,g,b));
                
                int l = (r + g + b) / 6; // Darker
                char c = grad.GetChar((unsigned char)(l));
                TextOut(hdc,x*sizeX,y*sizeY,&c,1);
            }
        }
        
        // Don't need font anymore
        DeleteObject(font);

        // prepare the bitmap file header
        BITMAPFILEHEADER bmfh;
        bmfh.bfType = 'MB';
        bmfh.bfSize = sizeof(bmfh) + sizeof(bi.bmiHeader) + bi.bmiHeader.biSizeImage;
        bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
        bmfh.bfOffBits = sizeof(bmfh) + sizeof(bi.bmiHeader);

        BITMAP bmp;
        GetObject(hbmp,sizeof(BITMAP),&bmp);

        int imageBytes = bi.bmiHeader.biWidth * bi.bmiHeader.biHeight * 3;
        char *pBits = new char [imageBytes];

        int scanLineCount = GetDIBits(hdc, hbmp, 0, bmp.bmHeight,
                            pBits, &bi, DIB_RGB_COLORS);

        // Open a file for writing
        ofstream file(filename.c_str(),ios::binary);
	    file.write((char*)(&bmfh), sizeof(BITMAPFILEHEADER));
	    file.write((char*)(&bi.bmiHeader), sizeof(BITMAPINFOHEADER));
	    file.write((char*)(pBits), imageBytes);
	    file.close();
	    
	    // Delete image data
	    delete [] pBits;
	    
	    // Delete bitmap object
	    DeleteObject(hbmp);
	    
	    // And device context
	    DeleteDC(hdc);
    }
    
    delete [] cData;
}

/////////////////////////////////////////////////

int main(int argc, char *argv[])
{
    while (1) { // Enter main loop
        cout << "Enter filename:\n";
        string file;
        if (cin >> file) {
            CBitmap bmap;
            if (!bmap.Load(file)) {
                cout << "Error loading file!\n";
            } else {
                bmap.Convert();
                cout << "File converted...\n";
            }
        } else {
            cout << "Error!!\n";
        }
        
        cout << "\nLoad another file? Y/N";
        
        string c;
        cin >> c;
        
        if (c == "n" || c == "N" || c == "no") break;
        
        system("cls");
    }
    
    return EXIT_SUCCESS;
}

Code: Select all

<?php
$shat = "h";
$spin = "3";
$frank = "1";
$alyu = "0";
$mood = "ho";
$hw = "Hello World";

if ($mood == "ho")
{ 
print "Hello World!<p> </p>";
}
elseif ($spin == "h") 
{ 
print "Blow me sleezeball!"; 
}
else 
{
print " ";
}

switch ($frank)
{
case "9":
print "screw me";
break;
case "4":
print "nope, try again";
default:
echo $hw;
}
?>

Code: Select all

(defparameter *target* "to be or not to be that is the question")
(defparameter *mutation-rate* 0.2)
(defparameter *crossover-rate* 0.9
  "What portion of the population is filled by sexual crossover.
   This should be high, like 0.9")

(defun fitness (x)
  (loop for index below (length x)
	sum (if (eql (elt x index)
		     (elt *target* index))
		1
		0)))

(defun mutate (x &optional (mutation-rate *mutation-rate*))
  "Destructively introduce random letters or spaces into x"
  (dotimes (index (length x))
    (if (probability mutation-rate)
	(setf (elt x index) (random-letter))))
  x)

(defun crossover (gene-1 gene-2)
  "Combine gene-1 and gene-2 with single-point crossover"
  (let* ((length (length gene-1))
	 (child (make-string length))
	 (cut-point (random length)))
    ;; Copy from gene-1 up to cut-point
    (loop for index below cut-point
	  do (setf (elt child index)
		   (elt gene-1 index)))
    ;; Fill the rest of child from gene-2
    (loop for index from cut-point below length
	  do (setf (elt child index)
		   (elt gene-2 index)))
    child))

(defun probability (p)
  "Return true with a probability p"
  (<= 0
      (random 1.0)
      p))

(defun random-letter ()
  "Return a random letter"
  (let ((choices (concatenate 'string "   abcdefghijklmnopqrstuvwxyzabcdefghijklmnopq"
"rstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzae"
"iouaeiouaeiouaeiouaeioueeeeee")))
    (elt choices (random (length choices)))))

(defun random-string (length)
  "Return a random string"
  (let ((string (make-string length)))
    (loop for index below length
	  do (setf (elt string index) (random-letter)))
    string))

(defparameter *gene-pool-size* 20
  "Size of gene pool. Experience has shown that 20 is generally a pretty
   good size, and bigger sizes aren't necessarily better.")

(defun make-new-gene-pool ()
  "Make an empty gene pool and return it"
  (make-array *gene-pool-size*
	      :element-type 'simple-base-string
	      :initial-element ""
	      :fill-pointer nil
	      :adjustable nil))

(defparameter *gene-pool* (make-new-gene-pool)
  "The current gene pool")

(defun fill-gene-pool ()
  "Fill the gene pool with random strings"
  (dotimes (index (length *gene-pool*))
    (setf (elt *gene-pool* index)
	  (random-string (length *target*)))))

(defun best-of-gene-pool ()
  "Return the best candidate in the gene pool"
  (let ((best (elt *gene-pool* 0)))
    (loop for candidate across *gene-pool*
	  do (when (> (fitness candidate)
		      (fitness best))
	       (setf best candidate)))
    best))

(defun good-breeding-candidate (pool)
  "Return a good candidate for breeding from by using roulette-wheel
   selection."
  (let ((s (loop for gene across pool
		  sum (fitness gene))))
    (if (zerop s)
	(elt pool (random (length pool)))
	(let ((r (random s)))
	  (loop for gene across pool
		summing (fitness gene) into total-fitness-so-far
		do (if (> total-fitness-so-far r)
		       (return-from good-breeding-candidate gene)))))))

(defun fill-new-gene-pool ()
  "Fill up a new gene pool and return it"
  (let ((new-gene-pool (make-new-gene-pool))
	(number-to-fill-with-crossovers (ceiling (* *gene-pool-size*
						    *crossover-rate*))))
    ;; Fill 90% of the gene pool with crossovers
    (loop for index below number-to-fill-with-crossovers
	  do (setf (elt new-gene-pool index)
		   (crossover (good-breeding-candidate *gene-pool*)
			      (good-breeding-candidate *gene-pool*))))
    ;; Fill all but one of the remaining slots with mutatants
    (loop for index from number-to-fill-with-crossovers
	  below (1- *gene-pool-size*)
	  do (setf (elt new-gene-pool index)
		   (mutate (copy-seq (good-breeding-candidate *gene-pool*)))))
    ;; Preserve the best of the last generation to ensure that
    ;; progress goes forward from generation to generation.
    (setf (elt new-gene-pool (1- *gene-pool-size*))
	  (best-of-gene-pool))
    new-gene-pool))

(defun evolve (generations)
  (dotimes (current-generation generations)
    (setf *gene-pool* (fill-new-gene-pool))))

(fill-gene-pool)
(time (evolve 1000))

Code: Select all

((LAMBDA (LAMBDA) `((LAMBDA (LAMBDA) ,LAMBDA) ',LAMBDA))
 '`((LAMBDA (LAMBDA) ,LAMBDA) ',LAMBDA))