Printable View
Hello i've been given the task of breaking an integer into bits (packing) to be sent across a network then unpacked. I can do the send code i'm just struggling to see how you break something into an int value as i dont understand the bit process we were given a 20 minutes presentation and are now expected to complete it s.any help would be great
I hope you took some notes so you can provide some clarification here. Are you sure you mean "bits" and not "bytes"?
Ints are already packed for purposes such as "sending them across a network". Perhaps what you are looking for has something to do with endianess? Network byte order is an (atavistic) big endian norm, whereas most computers are little endian.
sorry im not being clear the task says
use the individual bits of the two integers transmit the state across to the client (the ints they hold the game state x's and 0's)
its not very clear how its been written but we were told to use bitwise to send them as its smaller i guess its just to see how small they can be
Hmmm. Well, it is not really advantageous to say try and compress an int to make a transmission smaller since it requires processor time at both ends.
If the int is a bitfield, the individual bits are used as flags, however, you don't need to do anything to it, you can just transmit it as is -- an int is (normally) 4 bytes which is 32 bits. You don't have to create or extract them. The handling of each bit in the bitfield is done by the client.
Is that what this is about? Creating and using bitflags/bitfields?
sorry had to make a new account mine doesn't work for some reason.
The purpose it just to show it can be done. Basically its a network game of 0 and X's with a 3x3 grid. the server and client take turns, each time its stored in an ai or a player int then sent, the assignment just asks us to derive from the existing class then in the send function we transmit the individual bits in the 2 ints. The purpose is to make it smaller as an example of what can be done. However the presentation was damn awful and no one understood how to do it as the presentation didnt work when we coded it.
Right, that is a use for bitflags. So this is about a bitfield. However, you don't have to translate the ints into anything in order to do this, or transmit them as anything other than ints. The idea is this (let's use a single byte instead of 4 for simplicity):Quote:
Originally Posted by bdillion
00000000
One byte, eight bits. Each one can be either 1 or 0. So you can store boolean values this way. Let's pretend it is a 2x2 grid, and assign two bits to each square, since we need more than two possibilites (X, O, and empty). So 00 would be empty, 01 (ie, 1 in decimal) would be X, 10 (2 in decimal) would be O.
That's an OR mask, which you have probably used before with standard library functions:
You can set and test with a mask:Code:#define SQUARE_ISX 1
#define SQUARE_ISO 2
Here, "board" would be the int. Of course, you want more than one square per board. To do that, you have two choices:Code:board |= SQUARE_ISX; // set
if (board & SQUARE_ISX) //test with AND
- use #defines for each square eg, #define SQUARE2_ISX 4, (0100) This method might be easier and is in fact more efficient, I think. Just remember, each flag needs to be a power of 2 (1, 2, 4, 8, 16, etc) or else your flags will interfere with each other's bits.
- bitshift thru the int for each square.
For more info google "bitshifting", "bit fields", and "bitwise", cause bit wise is what you have to be here ;) :p
i've set it and the board is in an array called board
#define SQUARE_NULL 0
#define SQUARE_X 1
#define SQUARE_O 2
then tested it
board[1] |= SQUARE_X;
if (board[1] &= SQUARE_X)
but im not sure what it suppose to be testing because its not checking where on the board x is when the first place on the board is filled with an o it doesnt check its an o it just checks its full. I really not to sure on this part
I also tried
data->playerData = SQUARE_X;
data->aiData = SQUARE_O;
if(board[1] = SQUARE_O)
cout << "ai here";
however it says the ai is playing everyturn
Typo correction:Quote:
Originally Posted by MK27
:)Code:if (board & SQUARE_ISX) //test with AND
Post the entire program, if possible.Quote:
Originally Posted by bdillion
i'm working in server but have added both server and client so u can see whats happening the only class i can change is the main and dirvied class in server otherwise i would try changing the way the code works
this is the code
file.rar
No, I mean post the actual code (using code tags) here. Also:Quote:
Originally Posted by bdillion
...you're assigning a value there (not to mention that an equality test isn't what you want, anyway)...Code:if(board[1] = SQUARE_O)
Code:#include "stdafx.h"
#include <stdio.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <iostream>
#include <ctime>
#include <math.h>
#include <iostream>
#include <vector>
//#define bitwise
using namespace std;
// Noughts and Crosses (Tic Tack Toe) game
class NoughtsAndCrosses{
protected:
// 3 by 3 board is represented as a one dimensional array
char board[9];
// Players symbols are either X or O
char playerSymbol;
char aiSymbol;
// Game state
bool playerWin,aiWin,draw;
// If there is a winner or a draw update the state
bool CheckWin(char symbol){
bool won = false;
// Is there a winner?
// Check horizontal
if (board[0] == symbol && board[1] == symbol && board[2] == symbol) won = true;
if (board[3] == symbol && board[4] == symbol && board[5] == symbol) won = true;
if (board[6] == symbol && board[7] == symbol && board[8] == symbol) won = true;
// Check vertical
if (board[0] == symbol && board[3] == symbol && board[6] == symbol) won = true;
if (board[1] == symbol && board[4] == symbol && board[7] == symbol) won = true;
if (board[2] == symbol && board[5] == symbol && board[8] == symbol) won = true;
// Check diagonals
if (board[0] == symbol && board[4] == symbol && board[8] == symbol) won = true;
if (board[2] == symbol && board[4] == symbol && board[6] == symbol) won = true;
// If there is a winner who won?
if (won){
if (symbol == aiSymbol) aiWin = true;
else playerWin = true;
return true;
}
// If no one has won then check to see if it is a draw
for(int n=0;n<9;n++)
if (board[n] == ' ') return false;
draw = true;
return true;
}
public:
NoughtsAndCrosses(){
for(int n=0;n<9;n++)
board[n] = ' ';
playerSymbol = 'X';
aiSymbol = 'O';
playerWin = aiWin = draw = false;
}
bool IsFinished(){
if (playerWin || aiWin || draw) return true;
else return false;
}
void DisplayWinner(){
if (playerWin)
cout << "\n The Player has won \n";
else if (aiWin)
cout << "\n The AI has won \n";
else
cout << "\n Its a draw \n";
}
bool Play(char symbol, int pos){
// Ensure the position is free
if(board[pos]== ' '){
board[pos] = symbol;
CheckWin(symbol);
return true;
}
else return false;
}
void AIPlay(){
srand((unsigned)time(0));
int index;
do{
index = rand();
index = index % 9;
}
while(! Play('O', index));
}
void Dump(){
cout << board[0] << " | " << board[1] << " | " << board[2] << "\n";
cout << "--------\n";
cout << board[3] << " | " << board[4] << " | " << board[5] << "\n";
cout << "--------\n";
cout << board[6] << " | " << board[7] << " | " << board[8] << "\n";
}
// Transmit the whole object to the opponent
void Send(SOCKET s)
{
char newarray[sizeof(NoughtsAndCrosses)];
memcpy( newarray, this, sizeof(NoughtsAndCrosses));
int sendCount = send(s, newarray,sizeof(NoughtsAndCrosses), 0);
}
};
// Contains game data to be transmitted
struct GameData{
int playerData,aiData;//player =x ai = 0
};
class bitwiseNoughtsAndCrosses:NoughtsAndCrosses
{
#define SQUARE_NULL 0
#define SQUARE_X 1
#define SQUARE_O 2
/*#define SQUARE2_X 4
#define SQUARE2_O 8
#define SQUARE3_X 16
#define SQUARE3_O 32
#define SQUARE4_X 64
#define SQUARE4_O 128
#define SQUARE5_X 252
#define SQUARE5_O 516
#define SQUARE6_X 1032
#define SQUARE6_O 2064
#define SQUARE7_X 1
#define SQUARE7_O 2
#define SQUARE8_X 1
#define SQUARE8_O 2
#define SQUARE9_X 1
#define SQUARE9_O 2
*/
public:
vector<unsigned char> bits;
unsigned int totalBits, totalBytes;
void NoughtsAndCrosses(unsigned int size)
{
}
void Packing()
{
GameData *data = new GameData();
data->playerData = SQUARE_X;
data->aiData = SQUARE_O;
if(board[1] = SQUARE_O)
cout << "ai here";
}
void Send(SOCKET s)
{
}
void Unpacking()
{
}
};
Yo whoops! Bad one.Quote:
Originally Posted by Sebastiani
Also, in fact SQUARE_EMPTY is not necessary, I deleted that earlier from the post. Anyway, here's a demo that may clarify how this works for you. Notice the bitshifting in the defines, which makes it somewhat easier. I shift by two each time because we use two bits for each square:
You can obviously tailor this somewhat to set X or O within the functions, etc, so you don't have to use the flags in the method calls.Code:#include <iostream>
#define SQUARE0_X 1
#define SQUARE0_O 2
#define SQUARE1_X 1 << 2
#define SQUARE1_O 2 << 2
#define SQUARE2_X 1 << 4
#define SQUARE2_O 2 << 4
#define SQUARE3_X 1 << 6
#define SQUARE3_O 2 << 6
class Bitfield {
int field;
public:
Bitfield () { };
bool check (int flag) {
if (field & flag) return true;
return false;
}
void set (int flag) {
field |= flag;
}
void unset (int flag) {
field ^= flag;
}
~Bitfield() { };
};
using namespace std;
int main(int argc, const char *argv[]) {
Bitfield example;
example.set(SQUARE1_O);
example.set(SQUARE2_X);
if (example.check(SQUARE1_X)) cout << "S1 is X\n";
else if (example.check(SQUARE1_O)) cout << "S1 is O\n";
else cout << "S1 is empty\n";
if (example.check(SQUARE2_X)) cout << "S2 is X\n";
else if (example.check(SQUARE2_O)) cout << "S2 is O\n";
else cout << "S2 is empty\n";
if (example.check(SQUARE3_X)) cout << "S3 is X\n";
else if (example.check(SQUARE3_O)) cout << "S3 is O\n";
else cout << "S3 is empty\n";
example.unset(SQUARE2_X);
cout << "\nNow:\n";
if (example.check(SQUARE2_X)) cout << "S2 is X\n";
else if (example.check(SQUARE2_O)) cout << "S2 is O\n";
else cout << "S2 is empty\n";
return 0;
}
Why are you copying the data to a new buffer (rather than just sending "NoughtsAndCrosses" itself)? Also, the function should be virtual, as it needs to be overridden by derived classes.Code:void Send(SOCKET s)
{
char newarray[sizeof(NoughtsAndCrosses)];
memcpy( newarray, this, sizeof(NoughtsAndCrosses));
int sendCount = send(s, newarray,sizeof(NoughtsAndCrosses), 0);
}
Using defines like this isn't considered a good practice (macro "pollution"). Use enums, eg:Code:#define SQUARE_NULL 0
#define SQUARE_X 1
#define SQUARE_O 2
/*#define SQUARE2_X 4
#define SQUARE2_O 8
#define SQUARE3_X 16
#define SQUARE3_O 32
#define SQUARE4_X 64
#define SQUARE4_O 128
#define SQUARE5_X 252
#define SQUARE5_O 516
#define SQUARE6_X 1032
#define SQUARE6_O 2064
#define SQUARE7_X 1
#define SQUARE7_O 2
#define SQUARE8_X 1
#define SQUARE8_O 2
#define SQUARE9_X 1
#define SQUARE9_O 2
Also, as already mentioned, your bitmasks should be powers of two, and shouldn't overlap with eachother.Code:enum
{
ABC = 12,
XYZ = 13
};
Why are you even using "new" (not to mention that there is no corresponding "delete")? Just declare a local variable. At any rate, it isn't really clear what you're trying to do here. Moreover, if you are packing the board state into an integer, how are you to mark cells that aren't yet filled (eg, you need 3 states: X, O, and UNDEFINED (not set))?Code:void Packing()
{
GameData *data = new GameData();
data->playerData = SQUARE_X;
data->aiData = SQUARE_O;
if(board[1] = SQUARE_O)
cout << "ai here";
}
nothing but the derived class can be changed the other functions and classes above are prewritten for us
Nb, just corrected some mistakes in my last post, went a bit hard on the coffee this afternoon :p
The set & unset functions are not very good (unset toggles) but this gives the general idea behind bitflaging.
i just looked at the example, but i dont understand how that packing them as bits to send?
Right, so what you want is basically:Quote:
Originally Posted by MK27
Code:void unset (int flag)
{
field &= ~flag;
}
Well, did you read my post (with respect to the "state ambiguity")? How do you plan to imbed 3 states in a boolean (eg: binary) value?Quote:
Originally Posted by bdillion
I dont know i'm just using the code provided and trying to do what im told, i have 0 idea what im doing and i think i might fail this tbh i just dont understand it how you pack it and send it
Okay, this is the part where you have become confused: this has nothing to do with sending over the network, except in so far as it also saves space there. You just transmit the whole field as is. It's an int. An int is (usually) 32 bits. The bits are in the int already. You don't have to do anything further.Quote:
Originally Posted by bdillion
The "memory optimization" involved is because you can have 32 boolean flags in a single int. Since you need two flags per square, that's 16 squares in an int. There is some processor optimization too since there is less loading of values, and AND/OR are single operations in asm.
So if you are sending over a network, all that becomes compounded: only four bytes have to be transmitted, only 4 have to be received each turn, because the entire state of the board is contained in that one int. This is why it was recommended to you as a method. But it is still sent and recieved as an int. It is meaningless to talk about sending individual bits since that is not possible. The smallest unit you can send via the network layer is a byte. And you cannot "compress" bitfield information* because that is as compressed as it logically could be.
* well, with a very large one you could look for patterns, etc, as in normal compression. But I promise: no sane person would recommend doing that with one single int. You could trim the high zeros out but then you would have to add more information to indicate the size of the data, which will make it bigger than it started -- seriously, you are confused about this point.
but then how do i know how to pack them all im getting is outputs to the screen saying this is x this o, im really lost.
also i incorporated the example and it seems to think everything is an x
public:
int field;
bitwiseNoughtsAndCrosses () { };
bool check (int flag) {
if (field & flag) return true;
return false;
}
void set (int flag) {
field |= flag;
}
void unset (int flag)
{
field &= ~flag;
}
~bitwiseNoughtsAndCrosses() { };
void Packing()
{
bitwiseNoughtsAndCrosses example;
example.set(SQUARE1_O);
example.set(SQUARE2_X);
if (board[1] = (SQUARE1_X)) cout << "S1 is X\n";
else if (board[1]=(SQUARE1_O)) cout << "S1 is O\n";
else cout << "S1 is empty\n";
so im saying if board position 1 is a x write its an x
Sorry, but that code doesn't even really make sense! Okay, so I'm guessing you don't have a very firm grasp of the language, right? Well, as tough as it sounds, your best bet right now is head to the local bookstore/library and do some serious self-study. Once you have a grasp of the basics, you'll be ready to dive into the project. But until then, you should probably put this project on the back-burner.Quote:
Originally Posted by bdillion
Good luck!
Ah, well, I did not really mean for you to use the class, it was just a demonstration of the concept.Quote:
Originally Posted by bdillion
However, you could play with the demo program/tailor it yourself until you get the idea. It fairly simple once you understand, but I can remember being sort of intimidated by bit ops when first introduced to them.
You just have to focus on the fact that all data is stored in binary, that the byte is the smallest functional unit in C/C++, and there are 8 bits in a byte. Here's another approach to this that doesn't involve any of the bit manipulation syntax:
:2 means this member only needs two bits. The compiler will pad this out to a byte level, but since we have four, the struct will still only be the size of a single char. AFAIK, you can't have an array of these, so it is somewhat awkward for this purpose.Code:#include <iostream>
#define SETX 1
#define SETO 2
struct bitfield {
char s0:2;
char s1:2;
char s2:2;
char s3:2;
};
using namespace std;
int main(int argc, const char *argv[]) {
struct bitfield eg;
cout << "struct bitfield is only " << sizeof(struct bitfield) << " byte(s).\n";
eg.s1 = SETX;
eg.s3 = SETO;
if (eg.s1 == SETX) cout << "Square 1 is X\n";
if (eg.s2 == SETX) cout << "Square 1 is X\n";
return 0;
}
Don't freak out. And do play with this in a small program separate from your project, it will make you life much easier.
unfortunately i dont have time to read a c++ book we've been given 4 days to do this, we were taught very badly c++ this year and were expected to do this after about 5 hours of coding.
so im am kinda freaking out
Sure, I understand. Sometimes we end up with lousy professors. All I can say is: take a bad mark on this one, study like hell, and hopefully by the time your *next* project is due you will have enough understanding to tackle your assignments. In the meantime, though, it just isn't reasonable to expect us to teach you the language "from the ground up"...Quote:
Originally Posted by bdillion
Cheers!
Yes, I know the feeling. This is why you think the fastest route is to try and write everything into the project. Trust me, it isn't. You will just make a mess. Take an hour or two, maybe use that first demo class I gave you (or whatever) and focus just on bit manipulation. Maybe add a simple menu and input so you can set and unset squares and see the state of the field afterward Don't worry about the main code. Go back to that once you are comfortable with the concepts. You can also use your experiment later if something in the main code doesn't work the way you were expecting.Quote:
Originally Posted by bdillion
This will be worth it, because IMO that bitfield will be very central to how your whole thing works. Remember, the bitfield IS the board.
ok i understand the concept how how its trying to work all x and o are given a number x = 1 0= 0 anbd the position is also given a number 1= full 0= empty so x in position xero would be 11 and if no other spaces are full it would be 110000000000000000 16 bits 2 bytes, now im just confused how to actually make it so that it knows it full or empty
I am wondering why you are not using bitpacking for this...way simpler and shorter code. For one thing you are wasting two bits on each value when one will do (since it can only be X or O) so you could easily set up something like this:
Code:struct XandO
{
char Field00:1
char Field01:1
char Field02:1
char Field10:1
char Field11:1
char Field12:1
char Field20:1
char Field21:1
char Field22:1
// represents 9 bits, one for each square. X = true, O = false
};
// then do a union masking an int (memset to zero the extra bits are ignored)
union TPlayState
{
int packedPlayState;
struct XandO playBits;
};
// in your code create an instance
union TPlayState playState;
// memset this to zero. Normally it would take a C call but now:
int ZeroState = 0;
playState.packedPlayState = ZeroState;
// then to set a bit, say in the middle of the board, at coords 1,1:
playState.Field11 = true;
// To check that state of say 0,0 is just the opposite:
bool IsAnX = playState.Field00;
// Finally so make an int to xfer over the network
int totalPlayState = playState.packedPlayState;
// thats it
Ixnay Jeff; last time I played tick tack toe you start with a board with no X's or O's. So there are three possibilities per square, not 2. At least, this is what I have been presuming...Quote:
Originally Posted by jeffcobb
What do you mean by "full or empty"?Quote:
Originally Posted by bdillion
Erm it has been a long time since I played that. You are correct. Still my solution is sound, just change the bitpacking to
char Field00:2
char Field01:2
And use three states. I mean you have 32 bits to play with...
Yo dude that was post #25 :pQuote:
Originally Posted by jeffcobb
I'm sure bdillion will figure it all out in time. I dunno about 4 days tho...mebbe someone under-estimated some things...
jeffcobb-
just trying out your idea, when you set if its true or false
playState.Field00 = true;
is there a way i can find out what is x and what is o before. i tried
if (board[0] == playerSymbol)
{
playState.Field00 = true;
}
but it seems to think pos 0 in the array is full when it is not
Umm -- if each square can be either X or O or empty (like tic tac toe), you cannot use that method. It will work if all the squares are either X or O and never "empty" (you never explained the rules of the game).
with this method can i pack the whole thing ? i mean how does the fields know whats in them without logic like that
If you really want help, you're going to have to learn to pay attention to what people are saying to (and asking of) you WRT nailing down the requirements. You seem to either gloss over, or simply ignore requests for clarification (a good example is my post, #19, and then your "response", post #20). Sorry, but "I don't know" just doesn't cut it...
I don't understand your concern; I would amend my solution (based on MKs reminder that there can be a third state in X and O (I last played this game as a child, far longer ago that I would like to admit) thusly:Quote:
Originally Posted by bdillion
I was sorta kinda hoping you could extrapolate this from the previous post but since not, here it is spelt out in 1s and 0s..Code:typedef enum {stateEmpty, stateX, stateO} XandOStates;
struct XandO
{
char Field00:2
char Field01:2
char Field02:2
char Field10:2
char Field11:2
char Field12:2
char Field20:2
char Field21:2
char Field22:2
// represents 18 bits, two for each square. Empty = 0, X = 1, O = 2
// still plenty small enough to fit into a single int.
};
// then do a union masking an int (memset to zero the extra bits are ignored)
union TPlayState
{
int packedPlayState;
struct XandO playBits;
};
// in your code create an instance
union TPlayState playState;
// memset this to zero. Normally it would take a C call but now:
int ZeroState = 0;
playState.packedPlayState = ZeroState;
// then to set a Field, say in the middle of the board, at coords 1,1:
// not sure how you are marking your fields but lets say you have a 3x3 grid
// each grid element is a char that is one of: Empty = ' ', X = 'x' and O = 'o'
char XandOBoard[3][3];
// init all to empty
int x;
for(x = 0; x < 3; x++)
{
int y;
for(y = 0; y < 3; y++)
{
XandOBoard[x,y] = ' '; // set to empty
}
}
// note: memset would work well here too:
memset(XandOBoard, ' ', 9);
// anyhow you have some game play and want to pack the board...
// I could put the logic here but to be sane I will stick it into a function
playState.Field11 = getLogicState(XandOBoard[1][1]);
// To check that state of say 0,0 is just the opposite:
XandOState state = playState.Field00;
// set the boardmember with another function that is the opposite of
// getLogicState()
XandOBoard[0][0] = setLogicState(state);
// Finally so make an int to xfer over the network
int totalPlayState = playState.packedPlayState;
// thats it, send totalPlayState over the wire..
}
char getLogicState(char)
{
char cReturnValue = stateEmpty;
switch(char):
{
case 'x':
{
cReturnValue = stateX;
break;
}
case 'o':
{
cReturnValue = stateO;
break;
}
}
return cReturnValue;
}
char setLogicState(XandOState state)
{
char cReturnValue = ' ';
switch(state)
{
case stateX:
{
cReturnValue = 'x';
break;
}
case stateO:
{
cReturnValue = 'o';
break;
}
}
}
i am not simply glossing over it, your speaking to me as if i've been coding for years which i have no. I do not gloss over your suggestions i just dont understand you, dont misinterpret what i say. I clearly am lacking and understanding here and am asking questions based on what people post to get a better idea, your comments like that and the read a book ones are simply not useful at all as a: i dont have time and b: they do not help with my understanding. I appreciate you trying but if you have comment like that in future please hold your tongue
Dude cool your jets; he was referring to the requirements, specifically that each cell/square could be X, O or Empty (its that third state that I forgot having not played this in like 40 years and thus came up with the boolean true/false marker in error). He was just saying that if you had stated that up-front (nothing to do with coding) that I would not have made the mistake. Me, I am more ashamed of my dodgy memory for such a simple childs game.
In any event, the solution I pasted above will work; obviously you will need to do some of the leg-work in it but I showed how to pack/unpack the bits, how to convert a board value into a bitfield and back again. Its up to you to set all the board values and all the states and do the socket work which should be falling down simple....google for "beej sockets" if confused...
Jeff
PS: to get a firmer grasp on how this works take the above and wrap it in a simple main() console project and run it to get the feel for how it works and what you have left to do to finish the task...
Look, I'm not going to sugar-coat my responses just because you don't like to be criticized. You're unprepared for your assignment. Guess what? Your fault! Your responses are vague and so we have a hard time understanding what exactly you're wanting to do. Guess what? Your fault!Quote:
Originally Posted by bdillion
The bottom line is this: you asked for the advice and you got it - what you do with it is up to you.
I accept criticism however you are not helping your being an elitist prick, the other people in this thread are more than willing to explain it in terms i understand that i thank them for it so just stay out of this thread if you have nothing useful to say, guess what i know i was unprepared so is my whole class considering no one can get it to work due to poor teaching. Not my fault
perhaps i could have done additional reading but unfortunately given 4 days to do it i'm trying my hardest to read and work on something that is considered an advanced topic. I know professional coders who barely use this or need it
Uh I am a professional developer (inspite of what Mario would have everyone believe) and I use bit-packing all the time. This is not really an advanced topic (bitpacking in and of itself) but some of the design-level stuff can be. I tend to do more in the realm of embedded stuff so maybe that is why I do more of this. However to paraphrase Kennedy (the pres. not the guy here): You will find two classes of coders: one that looks at the requirements and finds a reason it won't work and another class that looks at them to find a way to make them work. Be one of the latter and you will always be sought-after.
Translation:Quote:
Originally Posted by bdillion
"I can accept criticism, unless of course it hurts my feelings. I would rather be spoon-fed answers than to actually have to think hard about the problem. I know I'm unprepared, but I'd rather blame my teacher than take responsibility for my own education. Perhaps I could have started reading last year (when I started this class), but now it's too late, and so I'm hoping these people will help me achieve the impossible. I bet professional programmers don't even need to understand binary operations."
What a maroon...
another thrilling wrong addition by yourself there i think i proved my own point that your too up yourself to accept criticism yourself. I'm sure your go far with that attitude
Actually, if you read the threads that I've started (seeking advice), you'll find that I am generally quite humble, open to honest criticism, and willing to accept when I am wrong. Moreover, if you look at all of my posts to this particular thread, it's pretty obvious that I was trying to help you. At any rate, right now you would really benefit by:Quote:
Originally Posted by bdillion
1) Studying the language as much as possible in preparation for this assignment during the next few days (anything beats a zero grade, after all).
2) Formulating your questions as concisely and clearly as possible, so as to maximize the quality of the responses that you receive.
Sure but we can't help you any further unless you actually slow down, read the replies, IGNORE the personality conflicts you percieve, and ANSWER questions, like the one I asked in post #35:Quote:
Originally Posted by bdillion
Otherwise I and everybody else just feel we are wasting our time. I was somewhat paranoid and often frustrated when I first joined here -- skip it. Sebastiani is one of the nicest members around. And pretty talented to boot. Don't take criticism personally. Nobody is trying to f**k with you, but sometimes "getting to the point" can appear intimidating.Quote:
Originally Posted by MK27
I dunno if you are going to be able to finish this assignment in time, but if you can pull your head out of a tailspin you can at least make a decent attempt, and maybe then take that to your prof and ask for an extension of a few days to get it done right rather than rush it and fail anyway. A lot of profs will grant one extension per semester. But you are going to have to be tactful and keep your attitude in check there too.
And please, please, please, don't get so upset. We know you are stressed out. That's nobodies fault as far as I am concerned, but don't make it worse for yourself.
Slow down. Read. Respond carefully and clearly. Programming is hard. You need to remain calm. Your assignment is not that complicated and it can be done here. The only thing standing in your way is your communication skills.
Sound advice MK; lets see if he can take it. Being a good programmer is never measured by how you do when things are easy but rather how you do when your back in against the wall, you have poor requirements given to you (as kinda happened here) and you have a fixed time to still be a winner (or a winer).
Our hero here can spend the supposedly few days he has left blaming others or he can take the help given him already and be done in an afternoon. Let's see how it turns out..
ok i appolgise, moving on
i was sent some hint sheets today because the amount of people complaining, and there vastly different from what we have discussed.
Im reading them atm will get back when i have a clearer picture. My idea is to work out if the board position is filled with aidata or player data then set a bit to 0 or 1 which is stored ina bit array with 16 bits 1 for position 1 for the type so the out put will be as follows
if we have a grid
x--
---
---
the out put would be
x= 1 0= 0
11 00 00
00 00 00
00 00 00
Right, so to access the Nth bit (using 0-based indexing) you can simply create a bitmask with the value of 1 bit-shifted left by N, and then use that mask to test (using bitwise AND) or set (using bitwise OR) the integer holding the data.Quote:
Originally Posted by bdillion
I still don't understand the nature of the game -- is it like tic tac toe, or what?
yeah its suppose to be tic tac toe, most of it was pre-coded which makes it more difficult as i can never see what he's doing with his code
this is my code so far
i set a bit array for position and one for x or 0 however it seems to think there is somthing in the board position even when theres not, its going to be a long night
Code:void pack()
{
GameData game = new GameData;
bitset<15> bits; // holds the symbol type
bits[0];
bits[1];
bits[2];
bits[3];
bits[4];
bits[5];
bits[6];
bits[7];
bits[8];
bits[9];
bits[10];
bits[11];
bits[12];
bits[13];
bits[14];
bits[15];
bitset<15> bp; // holds board position
bp[0];
bp[1];
bp[2];
bp[3];
bp[4];
bp[5];
bp[6];
bp[7];
bp[8];
bp[9];
bp[10];
bp[11];
bp[12];
bp[13];
bp[14];
bp[15];
if (board[0] != 0)
{
bp[0] = 1;
if(game.aiData == board[0])
{
cout<<"ai went here";
bits[0] = 1;
}
else
{
cout<<"player went here";
bits[0] = 0;
}
}
}
Being more of a pure C guy, I had forgotten about bitset. That will make your life easier.
Just to make sure I and everyone understand then:
Small problem: this is a set of 15 bits, indexed 0-14. You want a set of 16 bits, indexed 0-15. Now what is the purpose here:Code:bitset<15> bits; // holds the symbol type
You don't have to do that, the bits are initialized to zero (not sure what your purpose is...)Code:bits[0];
bits[1];
bits[2];
...etc.
Anyway, so I am guessing by "holds the symbol type" you mean this indicates whether this position has an X or an O. Which doesn't deal with empty, so:
Is the purpose of that (again, it should be 16) to indicate whether a square is occupied or not?Code:bitset<15> bp; // holds board position
hey
bits[0];
bits[1];
bits[2];
purpose was i thought they acted like as if the numbers were there position in the array
and yes the number of bits was wrong i forgot it starts at 0
Um, didn't we figure out that a bit is insufficient for this (the three states needed)? Would you like a working class to manage all of this that is debugged and ready to be used?
They exist automatically. It's like this:Quote:
Originally Posted by bdillion
That's ten ints and you can access them in order, array[0] to array[9]. But by declaring it as "int array[10]" it contains them already.Code:int array[10];
Usually array elements are not initialized to any particular value (meaning they could be anything) but bitsets I believe are initialized so that everything starts with a value of zero.
Still trying to determine how bdillion intends to deal with this. Looks to me like there will be one bitset to indicate if a square is occupied, and then (if so) one to indicate whether it contains X or O.Quote:
Originally Posted by jeffcobb
emailed my lecturer and he said 2 bytes is all u need 1 for each position 1 for each symbol, however 9 squares 9 potential symbols 9x9 = 18 thats 2 bytes and 2 bits?
No, if there are nine squares and you need 2 bits per position, that's 9x2 = 18 bits.Quote:
Originally Posted by bdillion
You could organize that several different ways, but I would stick to two arrays of 9 bits. The first array will indicate whether a square is occupied (1) or not (0). The second one will indicate what symbol is in the square (say 0 = O, 1 = X). That means the first one supersedes the second one, because otherwise the second one would initially indicate a board of all O's -- get it?
I have contributed all that I can to this goose chase; with about 10 lines of code he could take what I gave him and be done. I have an IPC server and an autoptr class to get going by tomorrow...
Let your lecturer know that he is an idiot. If I've done the little mathematics needed and accounted for mirroring correctly, you only 15 bits.* Are you expected to save that last bit as well?Quote:
emailed my lecturer and he said 2 bytes is all u need 1 for each position 1 for each symbol, however 9 squares 9 potential symbols 9x9 = 18 thats 2 bytes and 2 bits?
O_oQuote:
I have contributed all that I can to this goose chase; with about 10 lines of code he could take what I gave him and be done.
Yep. I read this stupid thread thinking I might find something interesting. I found a solved problem and a pedantic fool causing confusion. Lovely.
Soma
*Edit: I just realized that a much easier option exists. ;_;
That's terrific but so far it has not been done in any number of bits. I think the OP should focus on the basic procedures here and then if s/he has time left can consider some potential optimizations.Quote:
Originally Posted by phantomotap
Not sure what kind of smart pointer you need, but Boost has a pretty decent set of them, IMO. They don't have a non-shared, non-slicing version, though...but if you do need something like that, you're welcome to use mine (100% unrestricted license, of course). :)Quote:
Originally Posted by jeffcobb
O_oQuote:
That's terrific but so far it has not been done in any number of bits. I think the OP should focus on the basic procedures here and then if s/he has time left can consider some potential optimizations.
I don't know how my comments may have confused you; I'll try to be clear this time.
This, the above quote, is exactly my point. The suggestion offered so far present a clear and obvious solution to this problem. Those suggestions are what the OP should be working with.
At this level of educational development it is misleading at best to try and force an obscure representation when it clearly has nothing to do with the stated goal of understanding bit manipulation and integer packing.
[Edit]non-slicing version[/Edit]
O_o
What?
Soma
Actually I have that. It was my thought to include into it the possibility of overloading the [] operator and leveraging internal information to catch buffer under and over runs. Seems kinda obvious but as I mentioned in another thread I am trying to squeeze all the extra debugging tricks/info out of standard and semi-standard tools that I can. Probably a fools errand but I thought to try...Quote:
Originally Posted by Sebastiani
Interesting. The smallest number of bits I was able to get it done in was 18 (9 cells with three possible states each). I will be interested to see this...Quote:
Originally Posted by phantomotap
Nope. I'll be damned if I'm going to be responsible for leading the OP to such a confusing path.
Soma
The OP does seem to be scoring about a 12 on the confusion meter. Part of his problem is stress, part of it is lack of experience and part of it is several of us all submitting working yet different approaches to his problem. That is another reason I backed out of the conversation.Quote:
Originally Posted by phantomotap
It did bring something to mind though...has this forum ever done friendly contests to see who can submit the best solution to various problems like this? I think it would be a hoot for us more experienced folk and educational for the more junior members...and it would also do away with this sort of confusion...just a thought.
Anyhow back to my IPC system. On a roll and want to have something working before my head hits the pillow tonight...
It just allows you to clone an object (that you only have a pointer to the base class to) without it getting "sliced". All of the ones that I had seen required a 'clone' method - kind of a kludge, IMO. So I decided to work on the problem myself, and finally came up with a way to do it that only requires the class to be copy-constructible. Plus, as a bonus, each object internally uses just a single pointer as data, so it's as light-weight as, say, an std::auto_ptr (well, not quite - each class that uses the template creates an addition pointer of overhead, but hey).Quote:
Originally Posted by phantomotap
Just skimming over this thread, and if the goal is to represent all possible tic-tac-toe boards in the least space, then 15 bits is the typical answer I would expect. There are exactly 3^9 = 19683 possible board combinartions if you assume that the number of X's and O's can differ by more than one.Quote:
Originally Posted by phantomotap
You can get it down to 14 bits if you don't represent all the possible boards that contain a difference between the X's and O's of more than one. Not worth doing unless one is writing a compression algorithm of course.
Is there anything left to answer here?
I see. I'm an idiot. When I read your post my thoughts were "What business does a smart pointer have being polymorphic?".Quote:
I decided to work on the problem myself, and finally came up with a way to do it that only requires the class to be copy-constructible.
I'm just guessing, you store the underlying object by indirection through a proxy typed from a templated constructor of the smart pointer class and clone the proxy instance when you need a copy of the underlying object?
This would be the easier option I referenced. My first thoughts were needlessly complicated by considering the number of possible game variations as "pictures" instead of an ordered set of ternary values.Quote:
You can get it down to 14 bits if you don't represent all the possible boards that contain a difference between the X's and O's of more than one.
O_oQuote:
Not worth doing unless one is writing a compression algorithm of course.
If you are going that far, you could squeeze even more out of those records in the average case with some form of variable length encoding.
If the OP has been truthful, how does the lecturer have a job?Quote:
Is there anything left to answer here?
Soma
Yeah -- who on earth would consider saving 3 bits worth any kind of thought at all? IMO that whole discussion constitutes sabotaging the thread, since you are clearly doing the OP no kind of favour. Real nice. Are we supposed to be impressed?Quote:
Originally Posted by iMalc
Basically, yes - each class generates a global allocator object that handles construction/destruction, and a pointer to this object is stored in the smart pointer (so two pointers are actually required, not one, as I claimed earlier). Another cool thing about it is that the base class doesn't even have to have a virtual destructor.*Quote:
Originally Posted by phantomotap
Oh, and sorry for the OT discussion, BTW...
*I do realize that no sane programmer would define a base class having a non-virtual destructor. It's just that I've always had this fascination with writing code that overcomes limitations of the language, and one aspect of C++ that always irked me was the fact that destructors aren't virtual, by default. So when I realized that the mechanism for that could be added with little overhead, I went for it, naturally. :p
So...what did the OP eventually do?
Huh?!Quote:
Originally Posted by MK27
That was a genuine question. What question are we currently supposed to be answering? I haven't read the whole thread and I'm not going to go back and read all five pages now. I'm genuinely trying to work out if there's reason the OP hasn't featured in any of the posts on this page. I don't know what you're on about.
At the top of this page I'm seeing a question about whether a ttt board can be represented in only two bytes. I'm simply confirming that it can. As for why anyone would want to, I dunno.