This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

1

Coding / A few C++ Utilities!

« on: October 16, 2008, 01:06:19 am »

These are just a few utilities I wrote up a while back that I just thought I'd let you guys have at. (You've seen the logger and timer before.) These are designed for windows development, and would need to be modified to be used elsewhere.

These systems are by no means perfect, so I'm open to suggestions or bugfinds.

A brief explanation of the systems and other files you'll find:

Timer - A high resolution timer

Logger - A log system that allows the saving of debug messages. It also has fuctionality to create a console window if you're using this in a windowed app.

Notify - A few functions for creating at-runtime debug popup (MessageBoxes) with parameters for customization of when they show. (Debug/Release)

RegEdit - A simple interface to doing a few types of registry reads/writes.

'utilities.sln' - Visual Studio 2008 solution

'licence.txt' - The legal mumbo jumbo.

I'm currently working on a little utility to poll information about the system, as well as the current app (Such as finding out the computer name, or how much RAM your process is currently using.)

See attached!

2

Other Projects / [Completed] Critical System

« on: August 30, 2008, 02:01:15 am »

Didn't realize I needed a cross post

http://www.zfgc.com/index.php#?action=games&sa=view&id=68

=]

3

Discussion / [Tutorial] Make your own professional looking installer!

« on: July 11, 2008, 03:22:18 am »

Ever wanted to create a professional looking installer? Ever tried some install-engines, just to find them cluttered with nasty advertisements? (Yeah, I'm looking at you clickteam.) Well today, I'm gonna step you through making your own professional looking setup, with no obtrusive, ugly name dropping!

Figure 1: A professional looking install wizard


First thing's first, we're not going to be handcrafting each windows form on our own, so we are going to use a setup creating engine. The one I'm going to step you through using has a hard to notice (and hard to find for that matter) copyright notice, that you can only see by right clicking the title bar, and choosing 'About Setup' (If I hadn't told you where it was, would you have found it?)

Also, while I'm at it: There are many ways to create installers, and this is just a particularly effective path I've found to do such. You by no means have to follow my directions step by step, but they're there for those who want to.

Inno Setup is a fully scriptable installation package creator, with way more features than I'm going to cover today. I'm just going to get you set up with a simple installer, and let you explore on your own.

So go ahead and grab Inno Setup from: jrsoftware.org [exe, 1,385KB].

Next, we need a working environment. I reccomend something with a simple path. I'll be using a folder on my desktop:
C:\Users\Administrator\Desktop\installer

I've gone ahead and created a folder in my 'installer' directory called 'app_dir'.

Figure 2: A clean working environment.


Next, go ahead and copy everything that you're going to want to install into that directory.

I've got my executable, my help file, and my readme.

Figure 3: Files ready to go!


Okay then, lets fire up the IDE (Inno Setup Compiler 5.2.3 at time of writing.) that came with Inno Setup, and see what we're looking at.

Ah, a welcome screen. Conveniently enough, what we want to do is right there, in the second radio option. Go ahead and choose Create a new script file using the Script Wizard, and hit OK.

Figure 4: Welcome to Inno Setup!


Click next at the 'Welcome to the wizard screen'. No need to create an empty script, we want to use the wizard!

Allrighty then, the meat and potatoes! The Application Information page is the first real info that we can set about our setup. The required fields are in bold, everything else is up to you!

Figure 5: I'm going to call my application Test App


On the next page, you're going to be asked to set where you'd like to install to. The Program Files folder is a pretty safe (and default) bet. Again, you can name your application folder whatever you please, but it's common practice to have the folder match the name of the app, or to use a combonation of publisher\app. The check box for 'allow user to change the application folder' is just a nice thing to do, especially if the user doesn't install everything to program files. Leave the second box unchecked, we're not doing that sort of an install.

Figure 6: Install here please.


The Application files page has some fancy-doings to have us all set up with some instant-created shortcuts, and other nice things. Though if you're not careful, you might get your directory structure out of wack. So for now, leave the first three options the way they are (the executable file, and two check boxes.) Don't worry, we're going to change the script manually later.

Go ahead and click on the 'Add folder' button. Browse to the folder you created. I named mine 'app_dir'. Click Okay, then yes when it asks you about subdirectories. (Especially if you have them!)

Figure 7: Add Files.


The next page is all about creating shortcut icons. I reccomend at least toggling on the 'uninstall' icon, as well as allowing the user to disable folder creation.

Figure 8: Shortcuts for quickness!


Next, is the license, and info text pages. They all do basically the same thing, with the license being the only difference. The license requires the user to choose 'I Agree' before they're able to continue. I'm going to just use my readme in place of the usual license file, but any text or rtf document will do fine for any of these. (Note, none are required.)

Figure 9: Documentation!


The next page: Languages. Really up to you, I for one, speak English... sorta.

Onward!

The next (and final setting) page, is the compiler setting page. This page is used to specify a custom output directory, a custom icon for the installer, a name, and even a password. (Note: People can unpack these things pretty easy, don't think a password is protecting sensitive data!)

For now, I'm going to leave everything the default on that page. (setup.exe will be created in wherever I've saved my script, plus the folder 'Output' by default.)

So next on through it, and hit finish!

Hot damn, a script! And would I like to compile now? Nope, not yet! There are some changes we need to make first.

Scroll down to the section for [Files]. See the first entry there, the one for the 'MyProg.exe' in the Inno Setup folder? Get rid of that line, we don't need it.

Looking at the [Icons] section, we need to change three lines, assuming you checked the options for all the shortcuts. On my First, Fourth, and Fifth line, I have shortcuts to the "MyProg.exe", which is what we told the wizard would be the main application. Simply change them from MyProg.exe to whatever your executable name is.

Further, check down in the [Run] section. The sole entry needs to be changed to the correct executable name as well.

Go ahead and save the script, in the folder you created (not the app_dir folder, the one above it.(I named mine installer.iss)

All right, lets take her for a spin, click the fourth button on the toolbar, and away we go!

If everything went fine, you should see a finished message at the bottom of the output window!

Figure 10: Finished Building!


Go take a peek in the 'Output' folder created, and you should have a setup.exe! Run it, and what do you get? Your very own setup!

Figure 11: Setup!


I'll leave the rest of the exploring of the setup to you. Keep playing around with Inno Setup (The Help File is extremely good.) and see if you can't make it do some fancy stuff. It's incredibly powerful, even has its own scripting engine. If you have a question on a more advanced topic than was covered here, feel free to ask.

I hope there was something useful contained in here for someone. See you guys around!

The script file I created in this walkthough is attached, if anyone was interested. Note that it has absolute paths, and must be modified to work on your machine.

4

Coding / Simple C++ Logging System!

« on: June 02, 2008, 06:28:52 am »

Working on a C++ Windows app? Wish you had a place you could write debug info to while working? How about a nice log that you could write to a file? How about one that also writes to a console window?

But how do you get a console window if I'm doing a win32 application? Sure you could turn it on, or you could just ask the operating system to give it to you!

So here's a simple logger class I've written up and used in a couple of things. The class is meant to be static, and never instantiated. Just SRO it in, and go. Use is pretty straight forward, but the header is commented nicely to explain things more if you're curious.

Logger in a zip file [4.10KB]

And if you just want to take a peek without downloading, scroll down:

First, the legal mumbo jumbo:

Code: Text

1. /*
2.   Copyright (C) 2008 Chris "Nitz" Dailey and The Group of They
3.   http://thegroupofthey.com
4.  
5.   This software is provided 'as-is', without any express or implied
6.   warranty.  In no event will the authors be held liable for any damages
7.   arising from the use of this software.
8.  
9.   Permission is granted to anyone to use this software for any purpose,
10.   including commercial applications, and to alter it and redistribute it
11.   freely, subject to the following restrictions:
12.  
13.   1. The origin of this software must not be misrepresented; you must not
14.      claim that you wrote the original software. If you use this software
15.      in a product, an acknowledgment in the product documentation would be
16.      appreciated but is not required.
17.   2. Altered source versions must be plainly marked as such, and must not be
18.      misrepresented as being the original software.
19.   3. This notice may not be removed or altered from any source distribution.
20. */
21.  

Code: Text

1. /********************************************************************
2.         created:        2008/04/19
3.         created:        19:4:2008   0:42
4.         modified:       2008/06/01
5.         filename:       .\utl\logger\logger.h
6.         file base:      logger
7.         file ext:       h
8.         author:         Nitz
9.        
10.         purpose:        A static logger class. Tracks passed messages,
11.                                 and displays them to 'clog'. Can save them to file.
12.  
13.         notes:          Requires win32 headers. To disable the log system,
14.                                 Run in release mode, or manually edit the define
15.                                 lines below.
16. *********************************************************************/
17. #pragma once
18.  
19. #ifndef _LOGGER_H_
20. #define _LOGGER_H_
21.  
22. #ifndef _CRT_SECURE_NO_WARNINGS
23. #define _CRT_SECURE_NO_WARNINGS
24. #endif
25.  
26. //////////////////////////////////////////////////////////////////////////
27. //Standard includes.
28. #define WIN32_LEAN_AND_MEAN
29. #include <Windows.h>
30. #include <vector>
31. #include <string>
32. #include <exception>
33. #include <iostream>
34. #include <fstream>
35. #include <ctime>
36. #include <fcntl.h>
37. #include <io.h>
38. using namespace std;
39.  
40. #ifdef _DEBUG
41. #ifndef LOGGER
42. #define LOGGER
43. #endif
44. #endif
45.  
46. namespace utl
47. {
48.         class Logger
49.         {
50. #ifdef LOGGER
51.         private:
52.                 // The log
53.                 static vector<string> m_vLog;
54.  
55.                 // A temporary string for non-newlined log msgs.
56.                 static string m_szNoNewline;
57.  
58.                 // A handle for a console window. (And associated FILE*)
59.                 static HANDLE m_hConsole;
60.                 static FILE* m_fConsole;
61.  
62.                 //Holds onto stdout and stderr&#39;s pointers.
63.                 static FILE m_fOld_stdout;
64.                 static FILE m_fOld_stderr;
65.  
66.                 //Don&#39;t try to make an instance of this class!
67.                 Logger() {}
68.                 Logger(const Logger&) {}
69.                 Logger & operator=(const Logger&) {}
70.  
71.         public:
72.                 ~Logger();
73.  
74.                 //************************************
75.                 // Method:    write
76.                 // FullName:  utl::Logger::write
77.                 // Access:    public static
78.                 // Returns:   void
79.                 // Qualifier:
80.                 // Parameter: string szMsg - The message to add to the log.
81.                 // Parameter: bool bNewline - Add the log with a new line, or
82.                 //                 hold it in the temporary string.
83.                 //************************************
84.                 static void write(string szMsg, bool bNewline = true);
85.  
86.                 //************************************
87.                 // Method:    writeDateTime
88.                 // FullName:  utl::Logger::writeDateTime
89.                 // Access:    public static
90.                 // Returns:   void
91.                 // Qualifier:
92.                 // Parameter: void
93.                 // Notes:     Writes the current date and time to the log.
94.                 //************************************
95.                 static void writeDateTime(void);
96.  
97.                 //************************************
98.                 // Method:    writeFileNameA
99.                 // FullName:  utl::Logger::writeFileNameA
100.                 // Access:    public static
101.                 // Returns:   void
102.                 // Qualifier:
103.                 // Parameter: string szFileName
104.                 // Parameter: int iLineNumber
105.                 // Parameter: bool bFileNameOnly
106.                 // Notes:     Not to be called without the writeFileName macro below.
107.                 //************************************
108.                 static void writeFileNameA(string szFileName, int iLineNumber, bool bFileNameOnly= true);
109. #define writeFileName() writeFileNameA(__FILE__, __LINE__, true)
110.  
111.                 //************************************
112.                 // Method:    writeToFile
113.                 // FullName:  utl::Logger::writeToFile
114.                 // Access:    public static
115.                 // Returns:   void
116.                 // Qualifier:
117.                 // Parameter: string szFileName
118.                 // Notes:     Writes the log to a file.
119.                 //************************************
120.                 static void writeToFile(string szFileName);
121.  
122.                 //************************************
123.                 // Method:    openConsole
124.                 // FullName:  utl::Logger::openConsole
125.                 // Access:    public static
126.                 // Returns:   void
127.                 // Qualifier:
128.                 // Parameter: void
129.                 // Notes:     Opens a console window. Only one
130.                 //            console window can be assigned to an app.
131.                 //            Also, this remaps stdout & stderr (cout, clog, cerr)
132.                 //            to this new window.
133.                 //************************************
134.                 static void openConsole(void);
135.  
136.                 //************************************
137.                 // Method:    exitConsole
138.                 // FullName:  utl::Logger::exitConsole
139.                 // Access:    public static
140.                 // Returns:   void
141.                 // Qualifier:
142.                 // Parameter: void
143.                 // Notes:     Kills off an attached console window.
144.                 //            Reassigns stdout & stderr
145.                 //************************************
146.                 static void exitConsole(void);
147.  
148.                 //************************************
149.                 // Method:    consoleWrite
150.                 // FullName:  utl::Logger::consoleWrite
151.                 // Access:    public static
152.                 // Returns:   void
153.                 // Qualifier:
154.                 // Parameter: string msg
155.                 // Notes:     Writes a line to the console. Skips the log.
156.                 //************************************
157.                 static void consoleWrite(string msg);
158.  
159.                 //************************************
160.                 // Method:    consoleGoto
161.                 // FullName:  utl::Logger::consoleGoto
162.                 // Access:    public static
163.                 // Returns:   void
164.                 // Qualifier:
165.                 // Parameter: int x
166.                 // Parameter: int y
167.                 // Notes:     Moves the console write cursor to the
168.                 //            position specified. Doesn&#39;t check for
169.                 //            valid bounds.
170.                 //************************************
171.                 static void consoleGoto(int x = 0, int y = 0);
172.  
173.                 //************************************
174.                 // Method:    consoleEnableCursor
175.                 // FullName:  utl::Logger::consoleEnableCursor
176.                 // Access:    public static
177.                 // Returns:   void
178.                 // Qualifier:
179.                 // Parameter: bool on
180.                 // Notes:     Enables or disables the flashing cursor.
181.                 //************************************
182.                 static void consoleEnableCursor(bool on);
183.  
184.                 //************************************
185.                 // Method:    consoleSetWindowTitle
186.                 // FullName:  utl::Logger::consoleSetWindowTitle
187.                 // Access:    public static
188.                 // Returns:   void
189.                 // Qualifier:
190.                 // Parameter: string szTitle
191.                 // Notes:     Changes the console window title.
192.                 //************************************
193.                 static void consoleSetWindowTitle(string szTitle);
194.  
195.                 //************************************
196.                 // Method:    flushLog
197.                 // FullName:  utl::Logger::flushLog
198.                 // Access:    public static
199.                 // Returns:   void
200.                 // Qualifier:
201.                 // Parameter: void
202.                 // Notes:     Empties out the log.
203.                 //************************************
204.                 static void flushLog(void);
205.  
206.                 //////////////////////////////////////////////////////////////////////////
207.                 // For disabling in release:
208.                 //  Everything below this line becomes active if LOGGER is not defined.
209.                 //  It&#39;s a duplicate of the above functions, with empty bodies.
210.                 //  so you don&#39;t have to take calls to the logger out of your code,
211.                 //  but nothing will happen to slow you down. (I&#39;ll bet it gets optimized out.)
212.                 //////////////////////////////////////////////////////////////////////////
213. #else
214.         private:
215.                 Logger() {}
216.                 Logger(const Logger&) {}
217.                 Logger & operator=(const Logger&) {}
218.  
219.         public:
220.                 ~Logger() {}
221.                 static void write(string szMsg, bool bNewline = true) {}
222.                 static void writeDateTime(void) {}
223.                 static void writeFileNameA(string szFileName, int iLineNumber, bool bFileNameOnly= true) {}
224. #define writeFileName() writeFileNameA(__FILE__, __LINE__, true)
225.                 static void writeToFile(string szFileName) {}
226.                 static void openConsole(void) {}
227.                 static void exitConsole(void) {}
228.                 static void consoleWrite(string msg) {}
229.                 static void consoleGoto(int x = 0, int y = 0) {}
230.                 static void consoleEnableCursor(bool on) {}
231.                 static void consoleSetWindowTitle(string szTitle) {}
232.                 static void flushLog(void) {}
233. #endif /* ifdef LOGGER */
234.         };
235. }
236.  
237. #endif /* ifndef _LOGGER_H_ */
238.  

Code: Text

1. /********************************************************************
2.         created:        2008/04/19
3.         created:        19:4:2008   0:48
4.         modified:       2008/06/01
5.         filename:       .\utl\logger\logger.cpp
6.         file base:      logger
7.         file ext:       cpp
8.         author:         Nitz
9.        
10.         purpose:        Logger Implementation.
11. *********************************************************************/
12. #include "logger.h"
13.  
14. #ifdef LOGGER
15. //////////////////////////////////////////////////////////////////////////
16. //Static member variables
17. vector<string> utl::Logger::m_vLog;
18. string utl::Logger::m_szNoNewline;
19. HANDLE utl::Logger::m_hConsole = INVALID_HANDLE_VALUE;
20. FILE * utl::Logger::m_fConsole = NULL;
21. FILE utl::Logger::m_fOld_stderr;
22. FILE utl::Logger::m_fOld_stdout;
23.  
24.  
25. utl::Logger::~Logger()
26. {
27.         exitConsole();
28. }
29.  
30. void utl::Logger::write( string szMsg, bool bNewline /*= true*/ )
31. {
32.         //See if we&#39;re ready to write a full string.
33.         if (bNewline)
34.         {
35.                 string _old = szMsg;
36.                 //Is there something in the buffer?
37.                 if (m_szNoNewline.size())
38.                         szMsg = m_szNoNewline + szMsg;
39.  
40.                 //Clear the buffer
41.                 m_szNoNewline.clear();
42.  
43.                 //Append a newline.
44.                 szMsg += &#39;\n&#39;;
45.  
46.                 //Add it to the log.
47.                 m_vLog.push_back(szMsg);
48.  
49.                 //Display the message.
50.                 clog << _old + &#39;\n&#39;;
51.                
52.         }
53.         else
54.         {
55.                 //Add the current message to the current buffer.
56.                 m_szNoNewline += szMsg;
57.  
58.                 //Display message in clog.
59.                 clog << szMsg;
60.         }
61.  
62. }
63.  
64. void utl::Logger::writeDateTime( void )
65. {
66.         //Prevent variable recreation.
67.         static char* _t;
68.         static time_t current_time;
69.  
70.         //Get the current time (in __time64 format)
71.         time(&current_time);
72.        
73.         //Translate it to an ascii string
74.         _t = ctime(&current_time);
75.  
76.         //If the buffer isn&#39;t empty, write it.
77.         if (m_szNoNewline.size())
78.                 write("", true);
79.  
80.         //Add the string to the log
81.         m_vLog.push_back(string(_t));
82.        
83.         //Show it
84.         clog << _t;
85. }
86.  
87.  
88. void utl::Logger::writeFileNameA( string szFileName, int iLineNumber, bool bFileNameOnly/*= true*/ )
89. {
90.         char buf[MAX_PATH];
91.         char * b = buf;
92.         wsprintf(buf, szFileName.c_str());
93.         if (bFileNameOnly)
94.         {
95.                 while (*b != 0) b++; b--;
96.                 while (*b != &#39;\\&#39;) b--; b++;
97.         }
98.         wsprintf(b, "%s (line:%i)", b, iLineNumber);
99.         write(b, true);
100. }
101.  
102. void utl::Logger::writeToFile( string szFileName )
103. {
104.         fstream o;
105.         o.exceptions(0x7);
106.  
107.         try
108.         {
109.                 o.open(szFileName.c_str(), ios_base::out | ios_base::trunc);
110.                 for (size_t i = 0; i < m_vLog.size(); i++)
111.                         o.write(m_vLog[i].c_str(), (std::streamsize)m_vLog[i].length());
112.         }
113.         catch (...)
114.         {
115.                 cerr << "Error writing to file. Log may not have been saved!\n";
116.         }
117. }
118.  
119. void utl::Logger::openConsole( void )
120. {
121.         if ( m_hConsole == INVALID_HANDLE_VALUE )
122.         {
123.                 AllocConsole();
124.                 m_hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
125.                 int handle = _open_osfhandle( (intptr_t) m_hConsole, _O_TEXT );
126.                 m_fConsole = _fdopen( handle, "w" );
127.  
128.                 //Remap outputs, storing old first.
129.                 m_fOld_stdout = *stdout;
130.                 m_fOld_stderr = *stderr;
131.                 *stdout = *m_fConsole;
132.                 *stderr = *m_fConsole;
133.  
134.                 //Things go screwy if the std streams aren&#39;t clear.
135.                 cout.clear();
136.                 clog.clear();
137.         }
138. }
139.  
140. void utl::Logger::exitConsole( void )
141. {
142.         if ( m_hConsole != INVALID_HANDLE_VALUE )
143.         {
144.                 //Done with my console.
145.                 FreeConsole();
146.  
147.                 //Set back the stdstreams
148.                 *stdout = m_fOld_stdout;
149.                 *stderr = m_fOld_stderr;
150.  
151.                 //Close the file handle.
152.                 fclose( m_fConsole );
153.                 m_hConsole = INVALID_HANDLE_VALUE;
154.  
155.                 //Things go screwy if the std streams aren&#39;t clear.
156.                 cout.clear();
157.                 clog.clear();
158.         }
159. }
160.  
161. void utl::Logger::consoleWrite( string msg )
162. {
163.         cout << msg << endl;
164. }
165.  
166. void utl::Logger::consoleGoto( int x /*= 0*/, int y /*= 0*/ )
167. {
168.         if (m_hConsole == INVALID_HANDLE_VALUE)
169.                 return;
170.         static COORD dwCoord;
171.         dwCoord.X = x;
172.         dwCoord.Y = y;
173.         SetConsoleCursorPosition(m_hConsole, dwCoord);
174. }
175.  
176. void utl::Logger::consoleEnableCursor( bool on )
177. {
178.         if (m_hConsole == INVALID_HANDLE_VALUE)
179.                 return;
180.         CONSOLE_CURSOR_INFO info;
181.         GetConsoleCursorInfo(m_hConsole, &info);
182.         info.bVisible = on;
183.         SetConsoleCursorInfo(m_hConsole, &info);
184. }
185.  
186. void utl::Logger::consoleSetWindowTitle( string szTitle )
187. {
188.         if (m_hConsole == INVALID_HANDLE_VALUE)
189.                 return;
190.         SetConsoleTitle(szTitle.c_str());
191. }
192.  
193. void utl::Logger::flushLog( void )
194. {
195.         // The log can get big. Empty it out.
196.         m_vLog.clear();
197. }
198. #endif
199.  

5

Other Projects / [DEMO (Beta)] Critical System

« on: April 17, 2008, 08:20:08 pm »

Check out the most recent post for updated information!

Original post contents:

http://thegroupofthey.com/

There's a group of five of us, and we've got the remainder of this month, and the next 4 to design, code, polish, and ship a game. We don't have a title, as of yet, but just a genre, and style we're going for. Here's basically what we're looking at.

A 2D game play performer, similar in play style to old school Sonic The Hedgehog or Super Mario Brothers, as well as Super Smash Brothers. Game play will take place only in the "X" and "Y" dimensions, where as the graphics will be fully 3D (Figure, SSB, or New Super Mario Brothers). The style of the game will have an industry, machinist, steampunk feel, sort of that of the "Metropolis" level from Sonic The Hedgehog 2. The game world, ideally, will be a static over world, a la a Metroid game, where as more parts of the level become open as you complete tasks. Our 'robotic' hero (Who ideally will be somewhat of a cross between IG-88 and a Battle Droid, or something of that nature.) is attempting to re-assemble the machine that he's running around inside of. (Which may end up being the final boss.)

Regardless, we're always open for help, if you're interested in doing some texturing, modeling, animation, etc, feel free to get in touch.

Again, our website is http://thegroupofthey.com/, and I'm going to be keeping it up to date with progress of our project as it goes along. There's currently a pdf that is a representation of the slides we used in our pitch to get the game green lighted, that has some more details about the game.

A quick thing on the technical side; We will be using C/C++ for the game code. Tools or extensions will likely be done in C#, should there be any. We haven't yet decided what sort of graphics API, audio API, that we're going to use just yet, though we're leaning towards Direct3D 9 for drawing. Most of us are very familiar with OpenGL, so we'd like to experiment and attempt to learn D3D (Which could make a port to XNA easier in the future.).

Also, if you'd like to toss an idea in for a title, that'd be pretty cool too.

Thoughts, questions?

Thanks!

-nitz
http://thegroupofthey.com/

6

Coding / Using a class encapsulated enum without fully qualifying?

« on: March 20, 2008, 05:21:26 am »

Say I have a class such as:

Code: [Select]

typedef class _myClass
{
public:
enum Directions { UP = 0, DOWN, LEFT, RIGHT };
}MyClass;

When trying to get at one of the directions, I'd have to get at it by:

MyClass::UP

Is there a way I can scope things in, so that I can have access to it by just using UP?

Thoughts?

7

Feedback / 404'd.

« on: November 06, 2007, 02:04:22 am »

Picture's worth a thousand words, right?

8

Other Projects / [Completed] Spaceballs...

« on: November 04, 2007, 07:45:51 am »

Okay, so it's not really a game.

Really what this is, is more of me playing around with different features of the DirectX APIs. I used a little D3D, Direct Input, Direct Audio, to just get a few core concepts down, playing with ray picking, material switching and such. Nothing fancy.

But I digress. The point of the 'game' is to click the green balls, avoiding the red ones.

There's no win condition, no lose condition. You will however lose interest about 20 seconds in.

A quick note though: This was compiled with the latest DirectX SDK, so you will need the latest runtimes to play. (Just run this web updater from Microsoft)

Anyways, here's a screenshot and the game:

Mad exciting, no?
Controls: Mouse Move, Left click 'fire'. Escape, Exit.
Well, here you go: Download[3.50MB application/octet-stream]
Note: Self extracting archive. Extracts to c:\temp. Feel free to delete that stuff when you're done. </lazy>

Random questions I've been asked about this before (their answers):
Written in native C++, using the Win32 and DirectX 9 APIs.
No, the game's not fun.
Yes, you will hate the background music, no you can't turn it off.

9

Coding / Why the keyword "goto" is bad.

« on: November 04, 2007, 07:20:13 am »

To sum it up:



But seriously though, this question comes up more often than people realize. Lots of people have heard it's "bad practice", but not some don't exactly get what that means.

If you find yourself using the goto keyword, there is probably a better way.

This quote from cprogramming.com puts things quite in perspective:

In these simple and limited programming languages, goto may be used quite commonly, and this feature is included in C/C++ too. It is however, considered extremely bad practice.

The reason for this is simply that there are better alternatives. C and C++ provide more advanced control structures like various types of functions and loops, which not only make it easy to code a certain behavior, but safer. goto is still sometimes used for customized control, like breaking out of heavily nested loops.

It has been said that if your program does indeed require the use of goto, you should probably be redesigning the whole program to fix it properly instead of using a quick fix like goto.

If in doubt, don't use goto.

Just a random thought from a sleep deprived programmer.

10

Feedback / favicon?

« on: July 01, 2007, 05:30:32 am »

Something, anything? Just so I can tell zfgc apart from my other 39 tabs open :]

I did this (zfgc_favicon.ico, 1150 bytes) real quick like, if you just were needing something, but I needed something to set the bookmark apart from others :]

Cheers