void NetCity::Packetize(uint8* buf, uint16& size) { buf[0] = 'C'; buf[1] = 'D'; uint16 unitSize; putlong(&buf[2], m_unitData->m_id); NetUnit::PacketizeUnit(&buf[6], unitSize, m_unitData); size = 6 + unitSize; CityData* cityData = m_unitData->m_city_data; PUSHBYTE(m_isInitialPacket); PUSHLONG(cityData->m_slaveBits); PUSHLONG(cityData->m_shieldstore); PUSHLONG(cityData->m_shieldstore_at_begin_turn); PUSHLONG(cityData->m_net_gold); PUSHLONG(cityData->m_science); PUSHLONG(cityData->m_luxury); PUSHLONG(cityData->m_city_attitude); PUSHLONG64((uint64)cityData->m_built_improvements); #ifdef CTP1_TRADE uint8 numNonZeroResources = 0; sint32 resourceCountPosition = size++; sint32 i; for(i = 0; i < g_theResourceDB->NumRecords(); i++) { if(cityData->m_resources.GetResourceCount(i) > 0) { numNonZeroResources++; PUSHBYTE((uint8)i); PUSHSHORT((uint16)cityData->m_resources.GetResourceCount(i)); } } buf[resourceCountPosition] = numNonZeroResources; #endif sint32 i; PUSHLONG(cityData->m_population); for(i = 0; i < (sint32)POP_MAX; i++) { PUSHSHORT(cityData->m_numSpecialists[i]); } PUSHLONG(cityData->m_partialPopulation); PUSHLONG(cityData->m_sizeIndex); PUSHLONG(cityData->m_workerFullUtilizationIndex); PUSHLONG(cityData->m_workerPartialUtilizationIndex); PUSHDOUBLE(cityData->m_defensiveBonus); PUSHBYTE((uint8)cityData->m_founder); PacketizeResources(cityData->m_collectingResources, buf, size); PacketizeResources(cityData->m_sellingResources, buf, size); PacketizeResources(cityData->m_buyingResources, buf, size); sint32 r; for(r = 0; r < g_theResourceDB->NumRecords(); r++) { PUSHLONG(cityData->m_distanceToGood[r]); } }
thStatus thExecuteCode(char *blockname,CODEPTR code, CODEPTR codelimit) { #ifdef PHILDEBUG #ifdef NOTPOSIX #warning Phil says NOTPOSIX! #else #warning Phil says not NOTPOSIX! i.e. POSIX!! #endif #ifdef POINTER64 #warning Phil says POINTER64! #else #warning Phil says not POINTER64! #endif #ifdef USEMEMCPY #warning Phil says USEMEMCPY! #else #warning Phil says not USEMEMCPY! #endif #endif register CODEPTR pc; CODE rawopcode,opcode,ltype,rtype,lrtypes; DAINT nargs,result; register DAINT *sp; DAINT i,il,ir,*pi; DAFLOAT f,fl,fr,*pf; DADOUBLE d,dl,dr,*pd; DAINT index; sp = stack; pc = code; while(pc < codelimit){ /* printf("PC=%x, Op code %x, Stack=%x, SP=%x\n",pc,*pc,stack,sp);*/ rawopcode = *pc++; if(rawopcode >= OPLP){ /* New style */ ltype = (rawopcode & OPLEFTTYPEMASK) >> 8; rtype = (rawopcode & OPRIGHTTYPEMASK) >> 4; /* lrtypes = opcode & OPLRTYPEMASK;*/ opcode = rawopcode & OPCODEMASK; switch(opcode & OPGROUPMASK) { case OPPUSHGROUP: /* Pushes */ switch(opcode) { #ifdef USEMEMCPY void *tmpptr; #endif case OPPUSHINT: /* Float included in pushes */ if((rawopcode & OPRESTYPEMASK) == OPRDOUBLE){ /* printf("sp=%x, pc=%x\n",sp,pc);*/ #ifdef USEMEMCPY memcpy((void *)&d,((DADOUBLE *)pc)++,sizeof(DADOUBLE)); PUSHDOUBLE(d); #else #ifdef __sgi PUSHDOUBLE(*((DADOUBLE *)pc)); pc++; pc++; #else PUSHDOUBLE(*(DADOUBLE *)pc);/*phil*/ pc = (CODEPTR) (DADOUBLE *) ((DADOUBLE *)pc + 1); #endif #endif /* printf("sp=%x, pc=%x\n",sp,pc);*/ } else { PUSHINT(*pc++); } break; case OPPUSHPINT: /*Push a pointer*/ #ifdef USEMEMCPY PUSHPOINTER((memcpy(&tmpptr,(((DAINT **)pc)++),sizeof(void *)) ,tmpptr)); #else PUSHPOINTER(*(DAINT **)pc); /*phil*/ pc = (CODEPTR)(DAINT **) ((DAINT **)pc + 1); #endif break; case OPPUSHINTP: /*Push what a pointer points to */ if((rawopcode & OPRESTYPEMASK) == OPRDOUBLE){ #ifdef USEMEMCPY memcpy(&tmpptr,(((DAINT **)pc)++),sizeof(void *)); d = *(DADOUBLE *) tmpptr; #else d = **(DADOUBLE **)pc;/*phil*/ pc = (CODEPTR) (DADOUBLE **) ((DADOUBLE **)pc + 1); #endif PUSHDOUBLE(d);/*phil*/ } else { #ifdef USEMEMCPY memcpy(&tmpptr,(((DAINT **)pc)++),sizeof(void *)); PUSHINT(*(DAINT *) tmpptr); #else PUSHINT(**(DAINT **)pc);/*phil*/ pc = (CODEPTR) (DAINT **) ((DAINT **)pc + 1); #endif } break; case OPPUSHFUNCTION: /*Push a intrinsic function code */ PUSHINT(*pc++); break; } break; case OPEOLGROUP: sp--; /* Should empty the stack */ if(rtype == OPRDOUBLE) sp--; /* Double is two entries on stack */ break; case OPLINDEXGROUP: if(opcode==OPLFARG) { if(rtype==OPRINT) {POPINT(i);} else if(rtype==OPRFLOAT) {POPFLOAT(f);}/*phil*/ else {POPDOUBLE(d);}/*phil*/ POPINT(index); /* Pop the function code */ switch(index) { case 0: /* abs */ if(rtype==OPRINT) { if(i<0) i = -i; PUSHINT(i); } else if(rtype==OPRFLOAT) { if(f<0.0) f = -f; PUSHFLOAT(f);/*phil*/ } else { if(d<0.0) d = -d; PUSHDOUBLE(d);/*phil*/ } break; case 1: /* sqrt */ if(rtype==OPRINT) d = i; else if(rtype==OPRFLOAT) d = f; if(d>=0) d = sqrt(d); else { fprintf(STDERR,"Test block %s: sqrt(%f)\n",blockname,d); d = 0; } PUSHDOUBLE(d);/*phil*/ break; case 2: /* exp */ if(rtype==OPRINT) d = i; else if(rtype==OPRFLOAT) d = f; d = exp(d); PUSHDOUBLE(d);/*phil*/ break; case 3: /* sin */ if(rtype==OPRINT) d = i; else if(rtype==OPRFLOAT) d = f; d = sin(d); PUSHDOUBLE(d);/*phil*/ break; case 4: /* cos */ if(rtype==OPRINT) d = i; else if(rtype==OPRFLOAT) d = f; d = cos(d); PUSHDOUBLE(d);/*phil*/ break; case 5: /* tan */ if(rtype==OPRINT) d = i; else if(rtype==OPRFLOAT) d = f; d = tan(d); PUSHDOUBLE(d);/*phil*/ break; } break; } if(rtype==OPRFLOAT) { /* Floating point index */ POPFLOAT(f);/*phil*/ index = floatToLong(f); } else if(rtype==OPRDOUBLE) { /* Double */ POPDOUBLE(d);/*phil*/ index = floatToLong(d); } else { POPINT(index); } index -= ((opcode & 0xF000) == 0x1000 ? 0 : 1); /* ltype should always be == restype */ if(opcode == OPLINDEX || opcode == OPLINDEXB){ if(ltype == OPRDOUBLE) { FETCHDARRAY(d);/*phil*/ PUSHDOUBLE(d);/*phil*/ } else if (ltype == OPRFLOAT) { FETCHFARRAY(f);/*phil*/ PUSHFLOAT(f);/*phil*/ } else { FETCHIARRAY(i);/*phil*/ PUSHINT(i); } } else { /*pointer on stack*/ sp--; #ifdef POINTER64 sp--; #endif if(ltype == OPRDOUBLE) { /* *((DADOUBLE **)sp)++ = (*((DADOUBLE **)sp)+index);*/ /* The following works better on the alpha */ pd = *((DADOUBLE **)sp); pd += index; PUSHPOINTER(pd);/*phil*/ } else { /* Assume INT and FLOAT the same size */ /**((DAINT **)sp)++ = (*((DAINT **)sp)+index);*/ /* The following works better on the alpha */ pi = *((DAINT **)sp); pi += index; PUSHPOINTER(pi);/*phil*/ } } break; case OPEQUAL: /* Big ugly matrix of type conversions */ if(rtype==OPRINT) { POPINT(i); if(ltype==OPRINT) { SAVEINT(i); /* Save result in result variable *//*phil*/ PUSHINT(i); /* Put result back on stack */ } else if(ltype==OPRFLOAT) { f = i; /* Convert to floating */ SAVEFLOAT(f); /* Save variable *//*phil*/ PUSHFLOAT(f); /* Put back on stack *//*phil*/ } else { /* if(ltype==OPRDOUBLE) */ d = i; SAVEDOUBLE(d);/*phil*/ PUSHDOUBLE(d);/*phil*/ } } else if(rtype==OPRFLOAT) { POPFLOAT(f);/*phil*/ if(ltype==OPRINT) { i = floatToLong(f); SAVEINT(i); /* Save result in result variable *//*phil*/ *sp++ = i; } else if(ltype==OPRFLOAT) { SAVEFLOAT(f); /* Save variable *//*phil*/ *sp++ = *(DAINT *)&f; } else { /* if(ltype==OPRDOUBLE) */ d = f; SAVEDOUBLE(d);/*phil*/ PUSHDOUBLE(d);/*phil*/ } } else { /* if(rtype==OPRDOUBLE) */ POPDOUBLE(d);/*phil*/ if(ltype==OPRINT) { i = floatToLong(d); SAVEINT(i); /* Save result in result variable *//*phil*/ *sp++ = i; } else if(ltype==OPRFLOAT) { f = d; SAVEFLOAT(f); /* Save variable *//*phil*/ *sp++ = *(DAINT *)&f; } else { /* if(ltype==OPRDOUBLE) */ SAVEDOUBLE(d);/*phil*/ PUSHDOUBLE(d);/*phil*/ } } break; case OPLOGGROUP: /* Logic and Bit operations */ case OPSHIFTGROUP: /* Logic and Bit operations */ if(rtype==OPRINT) { POPINT(ir); } else if(rtype==OPRFLOAT) { POPFLOAT(f);/*phil*/ ir = floatToLong(f); } else { POPDOUBLE(d);/*phil*/ ir = floatToLong(d); } if(ltype==OPRINT) { POPINT(il); } else if(ltype==OPRFLOAT) { POPFLOAT(f);/*phil*/ il = floatToLong(f); } else { POPDOUBLE(d);/*phil*/ il = floatToLong(d); } switch(opcode) { case OPLOGOR: *sp++ = il || ir; break; case OPLOGXOR: *sp++ = (il != 0) ^ (ir != 0); break; case OPLOGAND: *sp++ = il && ir; break; case OPBITOR: *sp++ = il | ir; break; case OPBITXOR: *sp++ = il ^ ir; break; case OPBITAND: *sp++ = il & ir; break; case OPSHL: *sp++ = il << ir; break; case OPSHR: *sp++ = il >> ir; break; } break; case OPCOMPGROUP: /* Logic comparisons */ /* Result of Add amd MUL groups should now always be double */ case OPADDGROUP: /* Add and Subtract */ case OPMULGROUP: /* * / and % */ if(rtype==OPRINT) { POPINT(ir); dr = ir; } else if (rtype==OPRFLOAT) { POPFLOAT(fr);/*phil*/ dr = fr; } else { POPDOUBLE(dr);/*phil*/ } if(ltype==OPRINT) { POPINT(il); dl = il; } else if (ltype==OPRFLOAT) { POPFLOAT(fl);/*phil*/ dl = fl; } else { POPDOUBLE(dl);/*phil*/ } if(rtype!=OPRINT || ltype!=OPRINT){ switch(opcode) { case OPISEQUAL: *sp++ = dl == dr; break; case OPISNOTEQUAL: *sp++ = dl != dr; break; case OPISLT: *sp++ = dl < dr; break; case OPISGT: *sp++ = dl > dr; break; case OPISLE: *sp++ = dl <= dr; break; case OPISGE: *sp++ = dl >= dr; break; case OPADD: d = dl + dr; PUSHDOUBLE(d);/*phil*/ break; case OPSUB: d = dl - dr; PUSHDOUBLE(d);/*phil*/ break; case OPTIMES: d = dl * dr; /* Need to deal with overflow */ PUSHDOUBLE(d);/*phil*/ break; case OPIDIV: /* printf("OP=%x\n",rawopcode);*/ if(dr == 0.0) { fprintf(STDERR,"Test block %s: %f/0.0\n",blockname,dl); d = 0.0; } else { d = dl / dr; /* Need to deal with overflow and div 0 */ } *sp++ = floatToLong(d); break; case OPDIV: if(dr == 0.0) { fprintf(STDERR,"Test block %s: %f/0.0\n",blockname,dl); d = 0.0; } else { d = dl / dr; /* Need to deal with overflow and div 0 */ } PUSHDOUBLE(d);/*phil*/ break; case OPMOD: d = fmod(dl,dr); PUSHDOUBLE(d);/*phil*/ break; } } else { /* Both left and right are int */ switch(opcode) { case OPISEQUAL: *sp++ = il == ir; break; case OPISNOTEQUAL: *sp++ = il != ir; break; case OPISLT: *sp++ = il < ir; break; case OPISGT: *sp++ = il > ir; break; case OPISLE: *sp++ = il <= ir; break; case OPISGE: *sp++ = il >= ir; break; case OPADD: *sp++ = il + ir; break; case OPSUB: *sp++ = il - ir; break; case OPTIMES: *sp++ = il * ir; /* Need to deal with overflow */ break; case OPIDIV: /* printf("At OPIDIV all int branch\n");*/ if(ir == 0) { fprintf(STDERR,"Test block %s: %d/0.0\n",blockname,il); *sp++ = 0; } else { *sp++ = il / ir; } break; case OPDIV: if(ir == 0) { fprintf(STDERR,"Test block %s: %d/0.0\n",blockname,il); d = 0.0; } else d = dl / dr; /* Need to deal with overflow and div 0 */ PUSHDOUBLE(d);/*phil*/ break; case OPMOD: *sp++ = il % ir; /* Need to deal with overflow and div 0 */ break; } } break; case OPUNARY: /* Unary Operators */ switch(opcode) { case OPNEG: if(rtype==OPRINT) { i = -(*--sp); *sp++ = i; } else if (rtype==OPRFLOAT) { f = *(DAFLOAT *)(--sp); f = -f; *sp++ = *(DAINT *)&f; } else { POPDOUBLE(d);/*phil*/ d = -d; PUSHDOUBLE(d);/*phil*/ } break; case OPNOT: case OPCOMP: if(rtype==OPRINT) { POPINT(i); } else if(rtype==OPRFLOAT) { POPFLOAT(f);/*phil*/ i = floatToLong(f); } else { POPDOUBLE(d);/*phil*/ i = floatToLong(d); } i = (opcode == OPNOT ? !i : ~i); *sp++ = i; break; } break; default: fprintf(STDERR,"Test block %s: Operator %x not yet implimented\n", blockname,opcode); break; } /* Terminates switch */ } else { /* terminates if(rawopcode >=OPLP) *//* Old Style, May not work anymore */ switch(*pc++)
void NetCity2::Packetize(uint8* buf, uint16 &size) { size = 0; PUSHID(k_PACKET_CITY2_ID); PUSHLONG((uint32)m_data->m_home_city); PUSHLONG(m_data->m_gold_lost_to_crime); PUSHLONG(m_data->m_gross_gold); PUSHLONG(m_data->m_goldFromTradeRoutes); PUSHLONG(m_data->m_gross_production); PUSHLONG(m_data->m_net_production); PUSHLONG(m_data->m_production_lost_to_crime); PUSHLONG64((uint64)m_data->m_builtWonders); PUSHDOUBLE(m_data->m_food_delta); PUSHDOUBLE(m_data->m_gross_food); PUSHDOUBLE(m_data->m_net_food); PUSHDOUBLE(m_data->m_food_lost_to_crime); PUSHDOUBLE(m_data->m_food_consumed_this_turn); PUSHLONG(m_data->m_total_pollution); uint8 flags = (uint8)m_data->m_contribute_materials | ((uint8)m_data->m_contribute_military << 1) | ((uint8)m_data->m_buildCapitalization << 4) | ((uint8)m_data->m_walls_nullified << 5) | ((uint8)m_data->m_isInjoined << 6) | ((uint8)m_data->m_buildInfrastructure << 7); PUSHBYTE(flags); #if 0 DPRINTF(k_DBG_NET, ("city: %d, %d, %d, %d, %d, %d, %d, %d, %d\n", m_data->m_spied_upon, m_data->m_franchise_owner, m_data->m_franchiseTurnsRemaining, m_data->m_ignore_happiness, m_data->m_watchfulTurns, m_data->m_bioInfectionTurns, m_data->m_nanoInfectionTurns, m_data->m_convertedTo, m_data->m_convertedBy)); #endif PUSHBYTE((sint8)m_data->m_spied_upon); PUSHBYTE((sint8)m_data->m_franchise_owner); PUSHBYTE((sint8)m_data->m_franchiseTurnsRemaining); #ifdef _DEBUG #endif PUSHBYTE((sint8)m_data->m_watchfulTurns); PUSHBYTE((sint8)m_data->m_bioInfectionTurns); PUSHBYTE((sint8)m_data->m_nanoInfectionTurns); PUSHBYTE((sint8)m_data->m_convertedTo); PUSHBYTE((sint8)m_data->m_convertedBy); PUSHLONG(m_data->m_convertedGold); PUSHLONG(m_data->m_accumulated_food); PUSHLONG(m_data->m_foodVatPollution); sint8 govSetting = -1; if(m_data->m_useGovernor) { govSetting = (sint8)m_data->m_buildListSequenceIndex; } PUSHBYTE(govSetting); PUSHBYTE(m_isInitialPacket); }