Archives from S:\ Drive
Good to keep around methinks
This commit is contained in:
Amrit Panesar committed
1 parent
eadaf70b9e
commit
6dd63cc439
606 files changed
+50212
No files matched your search
@@ -0,0 +1,20 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio 2012
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Hangman", "Hangman\Hangman.vcxproj", "{7310FC30-2591-4B40-9580-33268702093E}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Release|Win32 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{7310FC30-2591-4B40-9580-33268702093E}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{7310FC30-2591-4B40-9580-33268702093E}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{7310FC30-2591-4B40-9580-33268702093E}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{7310FC30-2591-4B40-9580-33268702093E}.Release|Win32.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
@@ -0,0 +1,456 @@
|
||||
#include "stdhangman.h"
|
||||
|
||||
Hangman::Hangman()
|
||||
{
|
||||
attempts = 0;
|
||||
wordLength = 0;
|
||||
secretWord = "";
|
||||
wordList = vector<hangword>();
|
||||
adminList = vector<string>();
|
||||
//readdmins();
|
||||
readFromFile();
|
||||
blankguesses();
|
||||
doseed();
|
||||
}
|
||||
|
||||
void Hangman::blankguesses()
|
||||
{
|
||||
attempts = 0;
|
||||
string alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
for (unsigned int i = 0; i < alpha.length(); i++)
|
||||
{
|
||||
alphabet[i] = alpha[i];
|
||||
}
|
||||
}
|
||||
|
||||
void Hangman::displayMenu()
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
cls();
|
||||
fflush(stdout);
|
||||
centerline("Main Menu",1);
|
||||
centerline("==========================",2);
|
||||
centerline("1. Game Administration",3);
|
||||
centerline("2. Begin a game",4);
|
||||
centerline("3. Exit",5);
|
||||
centerline("==========================",6);
|
||||
cursorpos(1,7);
|
||||
cout << "Please make a selection" << endl << ":";
|
||||
string input;
|
||||
cin >> input;
|
||||
switch (input[0])
|
||||
{
|
||||
case '1':
|
||||
while(doadmin());
|
||||
break;
|
||||
case '2':
|
||||
while(playGame());
|
||||
break;
|
||||
case '3':
|
||||
break;
|
||||
default:
|
||||
writeline("Please make a valid selection [1-3]");
|
||||
writeline(2);
|
||||
}
|
||||
if ( input[0] == '3' )
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool Hangman::playGame()
|
||||
{
|
||||
chooseword();
|
||||
blankguesses();
|
||||
while (attempts <= 6)
|
||||
{
|
||||
while(!handleinput());
|
||||
if (revealedword == secretWord)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
cls();
|
||||
if (attempts >= 6)
|
||||
{
|
||||
centerline("Hangman - Loss", 1);
|
||||
centerline(secretWord, 4);
|
||||
centerline("Sorry! You loose this round", 8);
|
||||
}
|
||||
else
|
||||
{
|
||||
centerline("Hangman - Winner", 1);
|
||||
centerline(secretWord, 4);
|
||||
centerline("Congratulations! You guessed correctly",8);
|
||||
}
|
||||
writeline(2);
|
||||
|
||||
string input;
|
||||
while (true)
|
||||
{
|
||||
cout << "Play again?" << endl << "[Y/n]";
|
||||
cin >> input;
|
||||
if (toupper(input[0]) == 'Y')
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else if (toupper(input[0]) == 'N')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << "Please enter either Yes or No" << endl;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Hangman::notguessed(char inguess)
|
||||
{
|
||||
for (int j = 0; j < 26; j++)
|
||||
{
|
||||
if (alphabet[j] == inguess)
|
||||
{
|
||||
alphabet[j] = ' ';
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Hangman::doadmin()
|
||||
{
|
||||
cls();
|
||||
centerline("Hangman - Administration",1);
|
||||
centerline("Hangman Administrator Login",4);
|
||||
cursorpos(1,10);
|
||||
cout << "Please enter your password" << endl << ":";
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Hangman::isinword(char inguess)
|
||||
{
|
||||
string secret = getSecretWord();
|
||||
for (unsigned int i = 0; i < secret.length(); i++)
|
||||
{
|
||||
if (secret[i] == toupper(inguess))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void Hangman::drawletters()
|
||||
{
|
||||
for (int i = 0; i < 26; i++)
|
||||
{
|
||||
if (i == 0)
|
||||
{
|
||||
cursorpos (4,6);
|
||||
}
|
||||
if (i == 8)
|
||||
{
|
||||
cursorpos (4,8);
|
||||
}
|
||||
if (i == 16)
|
||||
{
|
||||
cursorpos (4,10);
|
||||
}
|
||||
if ( i == 24 )
|
||||
{
|
||||
cursorpos(4, 12);
|
||||
}
|
||||
cout << alphabet[i] << " ";
|
||||
}
|
||||
cursorpos(4, 18);
|
||||
cout << revealedword;
|
||||
}
|
||||
|
||||
bool Hangman::handleinput()
|
||||
{
|
||||
cls(); // clear screen
|
||||
drawseperator(); // do the separator thing
|
||||
centerline("Hangman",1); // screen title
|
||||
drawhangman();
|
||||
drawletters();
|
||||
fflush(stdout);
|
||||
cursorpos(0, 20);
|
||||
writeline("Please enter a letter");
|
||||
cout << ":";
|
||||
string input;
|
||||
cin >> input;
|
||||
char guess = input[0];
|
||||
guess = toupper(guess);
|
||||
if (isalpha(guess) && notguessed(guess))
|
||||
{
|
||||
if (isinword(guess))
|
||||
{
|
||||
revealchar(guess);
|
||||
}
|
||||
else
|
||||
{
|
||||
attempts++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << guess << " is an invalid input, please try again";
|
||||
pause();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void Hangman::revealchar(char input)
|
||||
{
|
||||
string secret = getSecretWord();
|
||||
for (unsigned int i = 0; i < secret.length(); i++)
|
||||
{
|
||||
if (secret[i] == input)
|
||||
{
|
||||
revealedword[i] = secret[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Hangman::readFromFile()
|
||||
{
|
||||
/*
|
||||
hangword holdword;
|
||||
ifstream hangmanfile ("wordlist.bin", ios::in|ios::binary|ios::ate);
|
||||
if (hangmanfile.is_open())
|
||||
{
|
||||
while(!hangmanfile.eof())
|
||||
{
|
||||
holdword.Read(hangmanfile);
|
||||
wordList.push_back(holdword);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << "Unable to open wordlist.bin for reading. Trying to create it.." << endl;
|
||||
*/
|
||||
initFile();
|
||||
// }
|
||||
}
|
||||
|
||||
void Hangman::initFile()
|
||||
{
|
||||
hangword holdword;
|
||||
ifstream hangwordtxt ("hangmanwordlist.txt", ios::in);
|
||||
int id = 1;
|
||||
if (hangwordtxt.is_open())
|
||||
{
|
||||
while (!hangwordtxt.eof())
|
||||
{
|
||||
string word = "";
|
||||
getline(hangwordtxt,word);
|
||||
for (unsigned int j = 0; j < word.length(); j++)
|
||||
{
|
||||
word[j] = toupper(word[j]);
|
||||
}
|
||||
holdword.setword(word);
|
||||
holdword.setid(id);
|
||||
wordList.push_back(holdword);
|
||||
id++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << "Error unable to open hangmanwordlist.txt for reading" << endl;
|
||||
pause();
|
||||
}
|
||||
hangwordtxt.close();
|
||||
if (wordList.size() != 0)
|
||||
{
|
||||
ofstream hangmanbin ("wordlist.bin", ios::out|ios::binary|ios::app);
|
||||
if (hangmanbin.is_open())
|
||||
{
|
||||
for (unsigned int i = 0; i < wordList.size(); i++)
|
||||
{
|
||||
wordList[i].Write(hangmanbin);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << "Error unable to open wordlist.bin for writing" << endl;
|
||||
pause();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cout << "No words in the wordlist. Not creating file." << endl;
|
||||
pause();
|
||||
}
|
||||
}
|
||||
|
||||
void Hangman::chooseword()
|
||||
{
|
||||
if (wordList.size() == 0)
|
||||
{
|
||||
hangword hang;
|
||||
hang.setid(0);
|
||||
hang.setword("TEST");
|
||||
wordList.push_back(hang);
|
||||
}
|
||||
int wordindex = rand()%wordList.size();
|
||||
setSecretWord(wordList[wordindex].getword());
|
||||
string rev = string(getSecretWord().length(),'_');
|
||||
revealedword = rev;
|
||||
}
|
||||
|
||||
void Hangman::drawhangman()
|
||||
{
|
||||
cursorpos(55, 10);
|
||||
switch (attempts)
|
||||
{
|
||||
case 0:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" |" << endl;
|
||||
break;
|
||||
case 1:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" |" << endl;
|
||||
break;
|
||||
case 2:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" |" << endl;
|
||||
break;
|
||||
case 3:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" /| |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" |" << endl;
|
||||
break;
|
||||
case 4:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" /|\\ |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" |" << endl;
|
||||
break;
|
||||
case 5:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" /|\\ |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" |" << endl;
|
||||
break;
|
||||
case 6:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" /|\\ |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" / |" << endl;
|
||||
break;
|
||||
case 7:
|
||||
cout <<" ___ " << endl;
|
||||
cursorpos(55, 11);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 12);
|
||||
cout <<" @ |" << endl;
|
||||
cursorpos(55, 13);
|
||||
cout <<" /|\\ |" << endl;
|
||||
cursorpos(55, 14);
|
||||
cout <<" | |" << endl;
|
||||
cursorpos(55, 15);
|
||||
cout <<" / \\ |" << endl;
|
||||
break;
|
||||
}
|
||||
cursorpos(55, 16);
|
||||
cout <<" ________|________" << endl;
|
||||
cursorpos(55, 17);
|
||||
cout <<" / | /|" << endl;
|
||||
cursorpos(55, 18);
|
||||
cout <<"/________________/ /" << endl;
|
||||
cursorpos(55, 19);
|
||||
cout <<"|________________|/" << endl;
|
||||
}
|
||||
|
||||
void Hangman::setSecretWord(string word)
|
||||
{
|
||||
secretWord = word;
|
||||
}
|
||||
string Hangman::getSecretWord()
|
||||
{
|
||||
return secretWord;
|
||||
}
|
||||
|
||||
void Hangman::setWordLength(int length)
|
||||
{
|
||||
wordLength = length;
|
||||
}
|
||||
int Hangman::getWordLength()
|
||||
{
|
||||
return wordLength;
|
||||
}
|
||||
|
||||
/***********************************
|
||||
___
|
||||
| |
|
||||
@ |
|
||||
/|\ |
|
||||
| |
|
||||
/ \ |
|
||||
________|________
|
||||
/ | /|
|
||||
/________________/ /
|
||||
|________________|/
|
||||
|
||||
************************************/
|
||||
@@ -0,0 +1,45 @@
|
||||
#ifndef HANGMAN_H
|
||||
#define HANGMAN_H
|
||||
|
||||
#include "stdhangman.h"
|
||||
|
||||
class Hangman
|
||||
{
|
||||
private:
|
||||
int attempts;
|
||||
vector<hangword> wordList;
|
||||
vector<string> adminList;
|
||||
string secretWord;
|
||||
string revealedword;
|
||||
int wordLength;
|
||||
char alphabet[26];
|
||||
bool emessage;
|
||||
string message;
|
||||
public:
|
||||
Hangman();
|
||||
bool playGame();
|
||||
void enterNewWords();
|
||||
bool isWin();
|
||||
void convertToUpper();
|
||||
void readFromFile();
|
||||
|
||||
void setSecretWord(string word);
|
||||
string getSecretWord();
|
||||
|
||||
void setWordLength(int length);
|
||||
int getWordLength();
|
||||
|
||||
void initFile();
|
||||
bool notguessed(char guess);
|
||||
bool isinword(char guess);
|
||||
bool doadmin();
|
||||
void displayMenu();
|
||||
void drawhangman();
|
||||
bool handleinput();
|
||||
void blankguesses();
|
||||
void revealchar(char reveal);
|
||||
void chooseword();
|
||||
void drawletters();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,96 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{7310FC30-2591-4B40-9580-33268702093E}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>Hangman</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v110</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v110</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="Hangman.cpp" />
|
||||
<ClCompile Include="main.cpp" />
|
||||
<ClCompile Include="md5.cpp" />
|
||||
<ClCompile Include="Hangword.cpp" />
|
||||
<ClCompile Include="stdhangman.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="Hangman.h" />
|
||||
<ClInclude Include="md5.h" />
|
||||
<ClInclude Include="stdhangman.h" />
|
||||
<ClInclude Include="hangword.h" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,45 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup>
|
||||
<Filter Include="Source Files">
|
||||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
|
||||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Header Files">
|
||||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
|
||||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
|
||||
</Filter>
|
||||
<Filter Include="Resource Files">
|
||||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
|
||||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="main.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="Hangman.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="md5.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="stdhangman.cpp">
|
||||
<Filter>Source Files</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="stdhangman.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="Hangman.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="md5.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="hangword.h">
|
||||
<Filter>Header Files</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,76 @@
|
||||
#include "stdhangman.h"
|
||||
|
||||
int hangword::getid()
|
||||
{
|
||||
return id;
|
||||
}
|
||||
void hangword::setid(int id)
|
||||
{
|
||||
this->id = id;
|
||||
}
|
||||
|
||||
void hangword::setword(string word)
|
||||
{
|
||||
this->word = word;
|
||||
}
|
||||
string hangword::getword()
|
||||
{
|
||||
return word;
|
||||
}
|
||||
|
||||
void hangword::Read(ifstream& file)
|
||||
{
|
||||
setid(readid(file));
|
||||
setword(readword(file));
|
||||
}
|
||||
|
||||
void hangword::Write(ofstream& file)
|
||||
{
|
||||
int id = getid();
|
||||
writeid(file, id);
|
||||
writeword(file, getword());
|
||||
}
|
||||
|
||||
void hangword::writeword(ofstream& file,const string& str)
|
||||
{
|
||||
// get the length of the string data
|
||||
unsigned int len = str.size();
|
||||
|
||||
// write the size:
|
||||
file.write( reinterpret_cast<const char*>( &len ), sizeof(len) );
|
||||
|
||||
// write the actual string data:
|
||||
file.write( str.c_str(), len );
|
||||
}
|
||||
|
||||
string hangword::readword(ifstream& file)
|
||||
{
|
||||
// this probably isn't the optimal way to do it, but whatever
|
||||
string str;
|
||||
|
||||
// get the length
|
||||
unsigned int len;
|
||||
file.read( reinterpret_cast<char*>( &len ), sizeof(len) );
|
||||
|
||||
// we can't read to string directly, so instead, create a temporary buffer
|
||||
if(len > 0)
|
||||
{
|
||||
char* buf = new char[len];
|
||||
file.read( buf, len );
|
||||
str.append( buf, len );
|
||||
delete[] buf;
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
inline void hangword::writeid(ofstream& file, int& num)
|
||||
{
|
||||
file.write(reinterpret_cast<char *>(&num),sizeof(int));
|
||||
}
|
||||
|
||||
int hangword::readid(ifstream& file)
|
||||
{
|
||||
int num;
|
||||
file.read(reinterpret_cast<char *>(&num),sizeof(int));
|
||||
return num;
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
fluorine
|
||||
steapsin
|
||||
gadoid
|
||||
optics
|
||||
master
|
||||
uninvasive
|
||||
nettable
|
||||
preintend
|
||||
scourge
|
||||
clinah
|
||||
planking
|
||||
autogenetic
|
||||
inweaved
|
||||
peipus
|
||||
corneal
|
||||
descendant
|
||||
premonopolizing
|
||||
wadmoll
|
||||
grimily
|
||||
anatolic
|
||||
uniced
|
||||
unendeared
|
||||
geothermic
|
||||
tarsier
|
||||
hartmann
|
||||
actuarially
|
||||
caffein
|
||||
antiexpressive
|
||||
refasten
|
||||
hostelling
|
||||
sacculus
|
||||
teazeling
|
||||
resolution
|
||||
demoralised
|
||||
fletcherizing
|
||||
decently
|
||||
mitrephorus
|
||||
reverser
|
||||
eudora
|
||||
comestible
|
||||
kilpatrick
|
||||
peroneal
|
||||
corporate
|
||||
provisional
|
||||
plaice
|
||||
atheneum
|
||||
juicing
|
||||
wintery
|
||||
ellipsoid
|
||||
avigation
|
||||
republicanism
|
||||
bocage
|
||||
frederika
|
||||
cleruch
|
||||
counterbracing
|
||||
uninstigated
|
||||
undocumented
|
||||
voyeurism
|
||||
catchfly
|
||||
scatomas
|
||||
overwore
|
||||
radiably
|
||||
rhoecus
|
||||
eighteenmo
|
||||
imperfectness
|
||||
siziness
|
||||
curable
|
||||
gradin
|
||||
breadroot
|
||||
heresy
|
||||
ophytic
|
||||
cosmopolitanizing
|
||||
cannoneer
|
||||
haverhill
|
||||
abingdon
|
||||
mentor
|
||||
dissimulator
|
||||
fazenda
|
||||
syrphid
|
||||
rockier
|
||||
inobservance
|
||||
hipbone
|
||||
duckiest
|
||||
interclub
|
||||
mollendo
|
||||
touche
|
||||
dionysius
|
||||
impedible
|
||||
intoner
|
||||
cichoriaceous
|
||||
nondrinkable
|
||||
nevada
|
||||
pithecanthropus
|
||||
upswinging
|
||||
humectant
|
||||
diakinesis
|
||||
capacitively
|
||||
nonaccord
|
||||
cilice
|
||||
exuviate
|
||||
@@ -0,0 +1,28 @@
|
||||
#ifndef WORD_H
|
||||
#define WORD_H
|
||||
|
||||
#include "stdhangman.h"
|
||||
|
||||
class hangword
|
||||
{
|
||||
private:
|
||||
int id;
|
||||
string word;
|
||||
public:
|
||||
void setid(int in);
|
||||
int getid();
|
||||
|
||||
void setword(string in);
|
||||
string getword();
|
||||
|
||||
void Read(ifstream& file);
|
||||
void Write(ofstream& file);
|
||||
|
||||
void writeword(ofstream& file,const string& str);
|
||||
string readword(ifstream& file);
|
||||
|
||||
void writeid(ofstream& file, int& num);
|
||||
int readid(ifstream& file);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,10 @@
|
||||
#include "stdhangman.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
Hangman game;
|
||||
game.displayMenu();
|
||||
|
||||
pause();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,363 @@
|
||||
/* MD5
|
||||
converted to C++ class by Frank Thilo (thilo@unix-ag.org)
|
||||
for bzflag (http://www.bzflag.org)
|
||||
|
||||
based on:
|
||||
|
||||
md5.h and md5.c
|
||||
reference implemantion of RFC 1321
|
||||
|
||||
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||||
rights reserved.
|
||||
|
||||
License to copy and use this software is granted provided that it
|
||||
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
|
||||
Algorithm" in all material mentioning or referencing this software
|
||||
or this function.
|
||||
|
||||
License is also granted to make and use derivative works provided
|
||||
that such works are identified as "derived from the RSA Data
|
||||
Security, Inc. MD5 Message-Digest Algorithm" in all material
|
||||
mentioning or referencing the derived work.
|
||||
|
||||
RSA Data Security, Inc. makes no representations concerning either
|
||||
the merchantability of this software or the suitability of this
|
||||
software for any particular purpose. It is provided "as is"
|
||||
without express or implied warranty of any kind.
|
||||
|
||||
These notices must be retained in any copies of any part of this
|
||||
documentation and/or software.
|
||||
|
||||
*/
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
|
||||
/* interface header */
|
||||
#include "md5.h"
|
||||
|
||||
/* system implementation headers */
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
// Constants for MD5Transform routine.
|
||||
#define S11 7
|
||||
#define S12 12
|
||||
#define S13 17
|
||||
#define S14 22
|
||||
#define S21 5
|
||||
#define S22 9
|
||||
#define S23 14
|
||||
#define S24 20
|
||||
#define S31 4
|
||||
#define S32 11
|
||||
#define S33 16
|
||||
#define S34 23
|
||||
#define S41 6
|
||||
#define S42 10
|
||||
#define S43 15
|
||||
#define S44 21
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
// F, G, H and I are basic MD5 functions.
|
||||
inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
|
||||
return x&y | ~x&z;
|
||||
}
|
||||
|
||||
inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
|
||||
return x&z | y&~z;
|
||||
}
|
||||
|
||||
inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
|
||||
return x^y^z;
|
||||
}
|
||||
|
||||
inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
|
||||
return y ^ (x | ~z);
|
||||
}
|
||||
|
||||
// rotate_left rotates x left n bits.
|
||||
inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
|
||||
return (x << n) | (x >> (32-n));
|
||||
}
|
||||
|
||||
// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
|
||||
// Rotation is separate from addition to prevent recomputation.
|
||||
inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
|
||||
a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
|
||||
a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
|
||||
a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
|
||||
a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////
|
||||
|
||||
// default ctor, just initailize
|
||||
MD5::MD5()
|
||||
{
|
||||
init();
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////
|
||||
|
||||
// nifty shortcut ctor, compute MD5 for string and finalize it right away
|
||||
MD5::MD5(const std::string &text)
|
||||
{
|
||||
init();
|
||||
update(text.c_str(), text.length());
|
||||
finalize();
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
void MD5::init()
|
||||
{
|
||||
finalized=false;
|
||||
|
||||
count[0] = 0;
|
||||
count[1] = 0;
|
||||
|
||||
// load magic initialization constants.
|
||||
state[0] = 0x67452301;
|
||||
state[1] = 0xefcdab89;
|
||||
state[2] = 0x98badcfe;
|
||||
state[3] = 0x10325476;
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
|
||||
void MD5::decode(uint4 output[], const uint1 input[], size_type len)
|
||||
{
|
||||
for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
|
||||
output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
|
||||
(((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// encodes input (uint4) into output (unsigned char). Assumes len is
|
||||
// a multiple of 4.
|
||||
void MD5::encode(uint1 output[], const uint4 input[], size_type len)
|
||||
{
|
||||
for (size_type i = 0, j = 0; j < len; i++, j += 4) {
|
||||
output[j] = input[i] & 0xff;
|
||||
output[j+1] = (input[i] >> 8) & 0xff;
|
||||
output[j+2] = (input[i] >> 16) & 0xff;
|
||||
output[j+3] = (input[i] >> 24) & 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// apply MD5 algo on a block
|
||||
void MD5::transform(const uint1 block[blocksize])
|
||||
{
|
||||
uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
|
||||
decode (x, block, blocksize);
|
||||
|
||||
/* Round 1 */
|
||||
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
|
||||
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
|
||||
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
|
||||
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
|
||||
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
|
||||
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
|
||||
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
|
||||
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
|
||||
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
|
||||
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
|
||||
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
|
||||
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
|
||||
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
|
||||
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
|
||||
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
|
||||
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
|
||||
|
||||
/* Round 2 */
|
||||
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
|
||||
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
|
||||
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
|
||||
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
|
||||
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
|
||||
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
|
||||
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
|
||||
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
|
||||
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
|
||||
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
|
||||
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
|
||||
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
|
||||
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
|
||||
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
|
||||
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
|
||||
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
|
||||
|
||||
/* Round 3 */
|
||||
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
|
||||
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
|
||||
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
|
||||
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
|
||||
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
|
||||
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
|
||||
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
|
||||
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
|
||||
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
|
||||
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
|
||||
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
|
||||
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
|
||||
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
|
||||
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
|
||||
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
|
||||
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
|
||||
|
||||
/* Round 4 */
|
||||
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
|
||||
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
|
||||
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
|
||||
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
|
||||
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
|
||||
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
|
||||
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
|
||||
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
|
||||
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
|
||||
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
|
||||
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
|
||||
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
|
||||
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
|
||||
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
|
||||
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
|
||||
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
|
||||
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
|
||||
// Zeroize sensitive information.
|
||||
memset(x, 0, sizeof x);
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// MD5 block update operation. Continues an MD5 message-digest
|
||||
// operation, processing another message block
|
||||
void MD5::update(const unsigned char input[], size_type length)
|
||||
{
|
||||
// compute number of bytes mod 64
|
||||
size_type index = count[0] / 8 % blocksize;
|
||||
|
||||
// Update number of bits
|
||||
if ((count[0] += (length << 3)) < (length << 3))
|
||||
count[1]++;
|
||||
count[1] += (length >> 29);
|
||||
|
||||
// number of bytes we need to fill in buffer
|
||||
size_type firstpart = 64 - index;
|
||||
|
||||
size_type i;
|
||||
|
||||
// transform as many times as possible.
|
||||
if (length >= firstpart)
|
||||
{
|
||||
// fill buffer first, transform
|
||||
memcpy(&buffer[index], input, firstpart);
|
||||
transform(buffer);
|
||||
|
||||
// transform chunks of blocksize (64 bytes)
|
||||
for (i = firstpart; i + blocksize <= length; i += blocksize)
|
||||
transform(&input[i]);
|
||||
|
||||
index = 0;
|
||||
}
|
||||
else
|
||||
i = 0;
|
||||
|
||||
// buffer remaining input
|
||||
memcpy(&buffer[index], &input[i], length-i);
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// for convenience provide a verson with signed char
|
||||
void MD5::update(const char input[], size_type length)
|
||||
{
|
||||
update((const unsigned char*)input, length);
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// MD5 finalization. Ends an MD5 message-digest operation, writing the
|
||||
// the message digest and zeroizing the context.
|
||||
MD5& MD5::finalize()
|
||||
{
|
||||
static unsigned char padding[64] = {
|
||||
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
if (!finalized) {
|
||||
// Save number of bits
|
||||
unsigned char bits[8];
|
||||
encode(bits, count, 8);
|
||||
|
||||
// pad out to 56 mod 64.
|
||||
size_type index = count[0] / 8 % 64;
|
||||
size_type padLen = (index < 56) ? (56 - index) : (120 - index);
|
||||
update(padding, padLen);
|
||||
|
||||
// Append length (before padding)
|
||||
update(bits, 8);
|
||||
|
||||
// Store state in digest
|
||||
encode(digest, state, 16);
|
||||
|
||||
// Zeroize sensitive information.
|
||||
memset(buffer, 0, sizeof buffer);
|
||||
memset(count, 0, sizeof count);
|
||||
|
||||
finalized=true;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// return hex representation of digest as string
|
||||
std::string MD5::hexdigest() const
|
||||
{
|
||||
if (!finalized)
|
||||
return "";
|
||||
|
||||
char buf[33];
|
||||
for (int i=0; i<16; i++)
|
||||
sprintf(buf+i*2, "%02x", digest[i]);
|
||||
buf[32]=0;
|
||||
|
||||
return std::string(buf);
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, MD5 md5)
|
||||
{
|
||||
return out << md5.hexdigest();
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
std::string md5(const std::string str)
|
||||
{
|
||||
MD5 md5 = MD5(str);
|
||||
|
||||
return md5.hexdigest();
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
/* MD5
|
||||
converted to C++ class by Frank Thilo (thilo@unix-ag.org)
|
||||
for bzflag (http://www.bzflag.org)
|
||||
|
||||
based on:
|
||||
|
||||
md5.h and md5.c
|
||||
reference implementation of RFC 1321
|
||||
|
||||
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||||
rights reserved.
|
||||
|
||||
License to copy and use this software is granted provided that it
|
||||
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
|
||||
Algorithm" in all material mentioning or referencing this software
|
||||
or this function.
|
||||
|
||||
License is also granted to make and use derivative works provided
|
||||
that such works are identified as "derived from the RSA Data
|
||||
Security, Inc. MD5 Message-Digest Algorithm" in all material
|
||||
mentioning or referencing the derived work.
|
||||
|
||||
RSA Data Security, Inc. makes no representations concerning either
|
||||
the merchantability of this software or the suitability of this
|
||||
software for any particular purpose. It is provided "as is"
|
||||
without express or implied warranty of any kind.
|
||||
|
||||
These notices must be retained in any copies of any part of this
|
||||
documentation and/or software.
|
||||
|
||||
*/
|
||||
|
||||
#ifndef BZF_MD5_H
|
||||
#define BZF_MD5_H
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
|
||||
// a small class for calculating MD5 hashes of strings or byte arrays
|
||||
// it is not meant to be fast or secure
|
||||
//
|
||||
// usage: 1) feed it blocks of uchars with update()
|
||||
// 2) finalize()
|
||||
// 3) get hexdigest() string
|
||||
// or
|
||||
// MD5(std::string).hexdigest()
|
||||
//
|
||||
// assumes that char is 8 bit and int is 32 bit
|
||||
class MD5
|
||||
{
|
||||
public:
|
||||
typedef unsigned int size_type; // must be 32bit
|
||||
|
||||
MD5();
|
||||
MD5(const std::string& text);
|
||||
void update(const unsigned char *buf, size_type length);
|
||||
void update(const char *buf, size_type length);
|
||||
MD5& finalize();
|
||||
std::string hexdigest() const;
|
||||
friend std::ostream& operator<<(std::ostream&, MD5 md5);
|
||||
|
||||
private:
|
||||
void init();
|
||||
typedef unsigned char uint1; // 8bit
|
||||
typedef unsigned int uint4; // 32bit
|
||||
enum {blocksize = 64}; // VC6 won't eat a const static int here
|
||||
|
||||
void transform(const uint1 block[blocksize]);
|
||||
static void decode(uint4 output[], const uint1 input[], size_type len);
|
||||
static void encode(uint1 output[], const uint4 input[], size_type len);
|
||||
|
||||
bool finalized;
|
||||
uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk
|
||||
uint4 count[2]; // 64bit counter for number of bits (lo, hi)
|
||||
uint4 state[4]; // digest so far
|
||||
uint1 digest[16]; // the result
|
||||
|
||||
// low level logic operations
|
||||
static inline uint4 F(uint4 x, uint4 y, uint4 z);
|
||||
static inline uint4 G(uint4 x, uint4 y, uint4 z);
|
||||
static inline uint4 H(uint4 x, uint4 y, uint4 z);
|
||||
static inline uint4 I(uint4 x, uint4 y, uint4 z);
|
||||
static inline uint4 rotate_left(uint4 x, int n);
|
||||
static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
|
||||
static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
|
||||
static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
|
||||
static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
|
||||
};
|
||||
|
||||
std::string md5(const std::string str);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,94 @@
|
||||
#include "stdhangman.h"
|
||||
|
||||
// Pause() use conio.h's get character to pause the program
|
||||
void pause()
|
||||
{
|
||||
int c;
|
||||
cout << endl << "Press any key to continue . . ." << endl;
|
||||
c = _getch();
|
||||
if (c == 0 || c == 224) // getch will return a 0 or 244 on error
|
||||
{
|
||||
_getch(); // try again
|
||||
}
|
||||
}
|
||||
|
||||
// cursorpos(X,Y) use ConsoleAPI to place the cursor at a particular position
|
||||
void cursorpos(int X, int Y)
|
||||
{
|
||||
if ( X < 0 ) // off the screen
|
||||
{
|
||||
X = 0;
|
||||
}
|
||||
if ( Y < 0 )
|
||||
{
|
||||
Y = 0;
|
||||
}
|
||||
HANDLE hStdOut = GetStdHandle( STD_OUTPUT_HANDLE ); //grab the stdout handle
|
||||
COORD newpos = { X, Y }; // use the Coord struct to stage the new position
|
||||
SetConsoleCursorPosition( hStdOut, newpos ); // set the new cursor position
|
||||
}
|
||||
|
||||
// take the input modulus the length by 80, set the cursor position there
|
||||
void centerline(string input, int linenum)
|
||||
{
|
||||
if (input.length() > 80) // over 80 characters? must be centred already
|
||||
{
|
||||
cursorpos(0,linenum);
|
||||
}
|
||||
int mod = (80-input.length())/2; // formula: input length subtracted from console line length divided by 2
|
||||
cursorpos(mod,linenum); // set where to write
|
||||
cout << input << endl; // write it
|
||||
}
|
||||
|
||||
// write a line
|
||||
void writeline(string input)
|
||||
{
|
||||
cout << ' ' << input << endl; // simple function to begin a line with a ' '
|
||||
}
|
||||
|
||||
// write a blank line
|
||||
void writeline(int num)
|
||||
{
|
||||
for (int i = 0; i <= num; i++) // easy function for multiple blank lines
|
||||
{
|
||||
cout << endl;
|
||||
}
|
||||
}
|
||||
|
||||
// do the separator thing
|
||||
void drawseperator()
|
||||
{
|
||||
for (int i = 2; i < 24; i++) // separates the hangman from the words
|
||||
{
|
||||
cursorpos(50,i);
|
||||
cout << "|";
|
||||
}
|
||||
}
|
||||
|
||||
// seed using micro time. much better than grabbing a random pointer.
|
||||
void doseed()
|
||||
{
|
||||
unsigned __int64 freq;
|
||||
QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
|
||||
double timerFrequency = (1.0/freq);
|
||||
|
||||
unsigned __int64 startTime;
|
||||
QueryPerformanceCounter((LARGE_INTEGER *)&startTime);
|
||||
srand(startTime*freq);
|
||||
}
|
||||
|
||||
// use the console api to fill the screen with spaces
|
||||
void cls() {
|
||||
HANDLE screen = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
COORD pos = {0, 0};
|
||||
DWORD written;
|
||||
CONSOLE_SCREEN_BUFFER_INFO screen_attr;
|
||||
unsigned size;
|
||||
|
||||
GetConsoleScreenBufferInfo(screen, &screen_attr);
|
||||
|
||||
size = screen_attr.dwSize.X * screen_attr.dwSize.Y;
|
||||
FillConsoleOutputCharacterW(screen, ' ', size, pos, &written);
|
||||
|
||||
SetConsoleCursorPosition(screen, pos);
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <fstream>
|
||||
#include <ctime>
|
||||
#include <ctype.h>
|
||||
|
||||
#include <Windows.h>
|
||||
#include <conio.h>
|
||||
#include "md5.h"
|
||||
|
||||
#include "Hangman.h"
|
||||
#include "hangword.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
void pause();
|
||||
void cursorpos(int x, int y);
|
||||
void centerline(string input, int linenum);
|
||||
void writeline(string input);
|
||||
void writeline(int num);
|
||||
void drawseperator();
|
||||
void doseed();
|
||||
void cls();
|
||||
Binary file not shown.
Reference in new issue
Block a user