void get_sub_matrix(int* ix,int* jx,const char* _major_x,int nrx,int ncx,double* x,const char* _major_y,int nry,int ncy,double* y)
{
int row_major_x = ((int)*_major_x == (int)'r') || ((int)*_major_x == (int)'R');
int row_major_y = ((int)*_major_y == (int)'r') || ((int)*_major_y == (int)'R');
if(!row_major_x && !row_major_y){
for(int i = 0;i < nry;i++){
int p = (ix ? ix[i] : i);
for(int j = 0;j < ncy;j++){
int q = (jx ? jx[j] : j);
y[CX(i,j,nry)] = x[CX(p,q,nrx)];
}
}
return;
}
if(!row_major_x && row_major_y){
for(int i = 0;i < nry;i++){
int p = (ix ? ix[i] : i);
for(int j = 0;j < ncy;j++){
int q = (jx ? jx[j] : j);
y[RX(i,j,ncy)] = x[CX(p,q,nrx)];
}
}
return;
}
if(row_major_x && row_major_y){
for(int i = 0;i < nry;i++){
int p = (ix ? ix[i] : i);
for(int j = 0;j < ncy;j++){
int q = (jx ? jx[j] : j);
y[RX(i,j,ncy)] = x[RX(p,q,ncx)];
}
}
return;
}
if(row_major_x && !row_major_y){
for(int i = 0;i < nry;i++){
int p = (ix ? ix[i] : i);
for(int j = 0;j < ncy;j++){
int q = (jx ? jx[j] : j);
y[CX(i,j,nry)] = x[RX(p,q,ncx)];
}
}
return;
}
}
void __attribute__((noreturn)) serial_recv_task(struct vcom * vcom)
{
struct serial_dev * serial = vcom->serial;
struct usb_cdc_class * cdc = vcom->cdc;
uint8_t buf[VCOM_BUF_SIZE];
int len;
DCC_LOG1(LOG_TRACE, "[%d] started.", thinkos_thread_self());
/* wait for line configuration */
usb_cdc_acm_lc_wait(cdc);
/* enable serial */
serial_enable(serial);
for (;;) {
len = serial_read(serial, buf, VCOM_BUF_SIZE, 1000);
if (len > 0) {
// dbg_write(buf, len);
if (vcom->mode == VCOM_MODE_CONVERTER) {
led_flash(LED_AMBER, 50);
usb_cdc_write(cdc, buf, len);
}
if (vcom->mode == VCOM_MODE_SDU_TRACE) {
led_flash(LED_AMBER, 50);
sdu_decode(buf, len);
}
#if RAW_TRACE
if (len == 1)
DCC_LOG1(LOG_TRACE, "RX: %02x", buf[0]);
else if (len == 2)
DCC_LOG2(LOG_TRACE, "RX: %02x %02x",
buf[0], buf[1]);
else if (len == 3)
DCC_LOG3(LOG_TRACE, "RX: %02x %02x %02x",
buf[0], buf[1], buf[2]);
else if (len == 4)
DCC_LOG4(LOG_TRACE, "RX: %02x %02x %02x %02x",
buf[0], buf[1], buf[2], buf[3]);
else if (len == 5)
DCC_LOG5(LOG_TRACE, "RX: %02x %02x %02x %02x %02x",
buf[0], buf[1], buf[2], buf[3], buf[4]);
else if (len == 6)
DCC_LOG6(LOG_TRACE, "RX: %02x %02x %02x %02x %02x %02x",
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
else if (len == 7)
DCC_LOG7(LOG_TRACE, "RX: %02x %02x %02x %02x %02x %02x %02x ",
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6]);
else
DCC_LOG8(LOG_TRACE, "RX: %02x %02x %02x %02x %02x %02x "
"%02x %02x ...", buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7]);
#endif
#if SDU_TRACE
RX(buf, len);
#endif
}
}
}
/* ************************************************** */
void rx(call_t *c, packet_t *packet) {
struct nodedata *nodedata = get_node_private_data(c);
struct _802_15_4_header *header = (struct _802_15_4_header *) packet->data;
array_t *up = get_entity_bindings_up(c);
int i = up->size;
/* cf p171 ref 802.15.4-2006: discard packet while in backoff */
if (nodedata->state != STATE_IDLE) {
packet_dealloc(packet);
return;
}
if ((header->dst != c->node) && (header->dst != BROADCAST_ADDR)) {
packet_dealloc(packet);
return;
}
while (i--) {
call_t c_up = {up->elts[i], c->node, c->entity};
packet_t *packet_up;
if (i > 0) {
packet_up = packet_clone(packet);
} else {
packet_up = packet;
}
RX(&c_up, packet_up);
}
return;
}
/* ************************************************** */
void rx(call_t *c, packet_t *packet) {
struct nodedata *nodedata = get_node_private_data(c);
array_t *up = get_entity_bindings_up(c);
int i = up->size;
struct routing_header *header = (struct routing_header *)
(packet->data + nodedata->overhead);
/* Forward packet if node is not the recipient */
if ((header->dst != BROADCAST_ADDR) && (header->dst != c->node) ) {
forward(c, packet);
return;
}
while (i--) {
call_t c_up = {up->elts[i], c->node, c->entity};
packet_t *packet_up;
if (i > 0) {
packet_up = packet_clone(packet);
} else {
packet_up = packet;
}
RX(&c_up, packet_up);
}
return;
}
void FPURegCache::MapReg(const int i, bool doLoad, bool makeDirty) {
pendingFlush = true;
_assert_msg_(JIT, !regs[i].location.IsImm(), "WTF - load - imm");
if (!regs[i].away) {
// Reg is at home in the memory register file. Let's pull it out.
X64Reg xr = GetFreeXReg();
_assert_msg_(JIT, xr >= 0 && xr < NUM_X_FPREGS, "WTF - load - invalid reg");
xregs[xr].mipsReg = i;
xregs[xr].dirty = makeDirty;
OpArg newloc = ::Gen::R(xr);
if (doLoad) {
if (!regs[i].location.IsImm() && (regs[i].location.offset & 0x3)) {
PanicAlert("WARNING - misaligned fp register location %i", i);
}
emit->MOVSS(xr, regs[i].location);
}
regs[i].location = newloc;
regs[i].lane = 0;
regs[i].away = true;
} else if (regs[i].lane != 0) {
// Well, darn. This means we need to flush it.
// TODO: This could be more optimal. Also check flags.
StoreFromRegister(i);
MapReg(i, doLoad, makeDirty);
} else {
// There are no immediates in the FPR reg file, so we already had this in a register. Make dirty as necessary.
xregs[RX(i)].dirty |= makeDirty;
_assert_msg_(JIT, regs[i].location.IsSimpleReg(), "not loaded and not simple.");
}
Invariant();
}
void dbg_buf_dump(void)
{
DCC_LOG1(LOG_TRACE, "dbg_cnt=%d", dbg_cnt);
if (dbg_cnt < DBG_BUF_LEN)
RX(dbg_buf, dbg_cnt);
else {
int n;
int tail = (dbg_head + 1) & (DBG_BUF_LEN - 1);
n = DBG_BUF_LEN - tail;
RX(&dbg_buf[tail], n);
if ((n = tail) > 0)
RX(&dbg_buf[0], n);
}
dbg_cnt = 0;
dbg_head = 0;
}
/* ************************************************** */
void rx(call_t *c, packet_t *packet) {
struct nodedata *nodedata = get_node_private_data(c);
array_t *up = get_entity_bindings_up(c);
int i = up->size;
/* radio sleep */
if (nodedata->sleep) {
packet_dealloc(packet);
return;
}
/* half-duplex */
if (nodedata->tx_busy != -1) {
packet_dealloc(packet);
return;
}
/* handle carrier sense */
if (nodedata->rx_busy == packet->id) {
nodedata->rx_busy = -1;
nodedata->rxdBm = MIN_DBM;
/* log rx */
PRINT_REPLAY("radio-rx1 %"PRId64" %d\n", get_time(), c->node);
/* consume energy */
battery_consume_rx(c, packet->duration);
} else {
packet_dealloc(packet);
return;
}
/* check wether the reception has killed us */
if (!is_node_alive(c->node)) {
packet_dealloc(packet);
return;
}
/* drop packet depending on the FER */
if (get_random_double() < packet->PER) {
packet_dealloc(packet);
return;
}
/* forward to upper layers */
while (i--) {
call_t c_up = {up->elts[i], c->node, c->entity};
packet_t *packet_up;
if (i > 0) {
packet_up = packet_clone(packet);
} else {
packet_up = packet;
}
RX(&c_up, packet_up);
}
return;
}
void EncryptedArrayDerived<type>::initNormalBasisMatrix() const
{
do {
typename Lazy< Pair< Mat<R>, Mat<R> > >::Builder
builder(normalBasisMatrices);
if (!builder()) break;
RBak bak; bak.save(); restoreContext();
REBak ebak; ebak.save(); restoreContextForG();
long d = RE::degree();
long p = tab.getZMStar().getP();
long r = tab.getR();
// compute change of basis matrix CB
mat_R CB;
CB.SetDims(d, d);
RE normal_element;
RE H;
bool got_it = false;
H = power(conv<RE>(RX(1, 1)), p);
do {
NTL::random(normal_element);
RE pow;
pow = normal_element;
VectorCopy(CB[0], rep(pow), d);
for (long i = 1; i < d; i++) {
pow = eval(rep(pow), H);
VectorCopy(CB[i], rep(pow), d);
}
Mat<ZZ> CB1;
conv(CB1, CB);
{
zz_pBak bak1; bak1.save(); zz_p::init(p);
Mat<zz_p> CB2;
conv(CB2, CB1);
got_it = determinant(CB2) != 0;
}
} while (!got_it);
Mat<R> CBi;
ppInvert(CBi, CB, p, r);
UniquePtr< Pair< Mat<R>, Mat<R> > > ptr;
ptr.make(CB, CBi);
builder.move(ptr);
} while(0);
}
void FASTCALL printPageNumber(LPWSTR maxGoldText, DWORD x, DWORD y, DWORD color, DWORD bfalse)
{
if (onRealm || !D2isLODGame() )
{
D2PrintString(maxGoldText,x,y,color,bfalse);
return;
}
Unit* ptChar = D2GetClientPlayer();
WCHAR popupText[100];
if (PCPY->currentStash)
{
bool isShared = PCPY->currentStash->isShared;
bool isIndex = PCPY->currentStash->isIndex;
DWORD currentId = PCPY->currentStash->id;
if (PCPY->currentStash->name && PCPY->currentStash->name[0])
mbstowcs(popupText,PCPY->currentStash->name,50);//strlen(PCPY->currentStash->name)+1
else _snwprintf(popupText, sizeof(popupText), getLocalString( isShared ? STR_SHARED_PAGE_NUMBER : STR_PERSONAL_PAGE_NUMBER), currentId+1);
D2PrintString(popupText, x, y, isShared ? (isIndex ? CRYSTAL_RED : RED) : (isIndex ? BRIGHT_WHITE : WHITE), bfalse);
} else {
_snwprintf(popupText, sizeof(popupText), getLocalString(STR_NO_SELECTED_PAGE));
D2PrintString(popupText, x, y, WHITE, bfalse);
}
//printGoldMaxPopup
DWORD mx = D2GetMouseX();
DWORD my = D2GetMouseY();
if ((RX(0x5E) < mx) && (mx < RX(0xF8)) && (RY(0x1C8) < my) && (my < RY(0x1B6)) )
{
if (active_sharedGold)
{
_snwprintf(popupText, sizeof(popupText), L"%s\n%s: %u", maxGoldText, getLocalString(STR_SHARED_GOLD_QUANTITY), PCPY->sharedGold);
DWORD x = D2GetPixelLen(maxGoldText);
DWORD x2 = D2GetPixelLen(popupText) - x;
D2PrintPopup(popupText, RX(0xA8-max(x,x2)/2), RY(0x1CA), WHITE, 0);
} else
D2PrintPopup(maxGoldText, RX(0xA8), RY(0x1CA), WHITE, 1);
}
}
void manageStatLine(Unit* ptChar, statsInterfaceBIN* statLine, int currentPage, LPWSTR lpText)
{
if (!statLine->enabled)
return;
if (statLine->page != currentPage)
return;
if (statLine->font)
D2SetFont(statLine->font);
printStat(ptChar, statLine->statsID, RX(statLine->x), RY(statLine->y), statLine->color, lpText);
}
/* ************************************************** */
void forward(call_t *c, packet_t *packet) {
struct nodedata *nodedata = get_node_private_data(c);
call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity};
struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead);
struct neighbor *n_hop = get_nexthop(c, &(header->dst_pos));
destination_t destination;
/* delivers packet to application layer */
if (n_hop == NULL) {
array_t *up = get_entity_bindings_up(c);
int i = up->size;
while (i--) {
call_t c_up = {up->elts[i], c->node, c->entity};
packet_t *packet_up;
if (i > 0) {
packet_up = packet_clone(packet);
} else {
packet_up = packet;
}
RX(&c_up, packet_up);
}
return;
}
/* update hop count */
header->hop--;
if (header->hop == 0) {
nodedata->data_hop++;
packet_dealloc(packet);
return;
}
/* set mac header */
destination.id = n_hop->id;
destination.position.x = -1;
destination.position.y = -1;
destination.position.z = -1;
if (SET_HEADER(&c0, packet, &destination) == -1) {
packet_dealloc(packet);
return;
}
/* forwarding packet */
nodedata->data_tx++;
TX(&c0, packet);
}
CTransform CTransform::RotateX(const F& angle)
{
F sinx = sin(CMath::Deg2Rad(angle));
F cosx = cos(CMath::Deg2Rad(angle));
CMatrix4x4 RX(1.0, 0.0, 0.0, 0.0,
0.0, cosx, -sinx, 0.0,
0.0, sinx, cosx, 0.0,
0.0, 0.0, 0.0, 1.0);
CMatrix4x4 invRX(RX);
invRX.Transpose();
return CTransform(RX, invRX);
}
void rx(call_t *c, packet_t *packet) {
array_t *up = get_entity_bindings_up(c);
int i = up->size;
while (i--) {
call_t c_up = {up->elts[i], c->node, c->entity};
packet_t *packet_up;
if (i > 0) {
packet_up = packet_clone(packet);
} else {
packet_up = packet;
}
RX(&c_up, packet_up);
}
return;
}
void IRQ3ISR()
{
int dismiss;
dismiss = inportb(COM2_IOBASE+IIR); // dismiss irq3
switch(dismiss) //switch read result
{
// call TX() and break(send char to terminal)
case IIR_TXRDY:
TX();
break;
//call RX() and break(send char from terminal)
case IIR_RXRDY:
RX();
break;
}
if(port_data.TXRDY ==1) //if TXRDY in port data equals to 1**************
TX(); //call TX() (check if can use it now to trasmit out a char)
}
bool Enemy::IsCollision( Character *player )
{
Rect pl, en;
pl.x = player->RX();
pl.y = player->RY();
pl.w = player->RW();
pl.h = player->RH();
en.x = RX();
en.y = RY();
en.w = RW();
en.h= RH();
return ( pl.x < en.x+en.w &&
pl.x+pl.w > en.x &&
pl.y < en.y+en.h &&
pl.y+pl.h > en.y );
}
void FPURegCache::Flush() {
for (int i = 0; i < NUM_MIPS_FPRS; i++) {
if (regs[i].locked) {
PanicAlert("Somebody forgot to unlock MIPS reg %i.", i);
}
if (regs[i].away) {
if (regs[i].location.IsSimpleReg()) {
X64Reg xr = RX(i);
StoreFromRegister(i);
xregs[xr].dirty = false;
} else if (regs[i].location.IsImm()) {
StoreFromRegister(i);
} else {
_assert_msg_(DYNA_REC,0,"Jit64 - Flush unhandled case, reg %i PC: %08x", i, mips->pc);
}
}
}
}
int main(void)
{
DDRB=0xFF;//0b00001011;
DDRD=0xFB;//0b10000000;
PORTB=0x02;//0b00000000;
PORTD=0x00;
TCCR0 = 0x7d;//0b01101101;
TCCR2 = 0x04;//0b00000000;
OCR0=OCR_val;///2)*-5)-1;
//TCNT0=55;
//TCCR1B = 0x04; //256
//TCNT1 = 65535; //
TIMSK = 0x41; //using Time1 16bit timer
MCUCR = 0x03;
GICR = 0x40;
UCSRA = 0x00;
UCSRB = 0x18;
UCSRC = 0x06;
UBRRH = 0x00;
UBRRL = 103; //9600 baud rate
//DDRD=0x02; //Rx:Input, Tx:Output
SREG = 0x80;
while(1)
{
RX(); //recieve data from computer
TX(temp); //return data to computer
TX(' ');
}
return 0;
}
/* ************************************************** */
void rx(call_t *c, packet_t *packet) {
struct nodedata *nodedata = get_node_private_data(c);
array_t *up = get_entity_bindings_up(c);
int i = up->size;
struct routing_header *header = (struct routing_header *) (packet->data + nodedata->overhead);
switch(header->type) {
case HELLO_PACKET:
nodedata->hello_rx++;
add_neighbor(c, header);
packet_dealloc(packet);
break;
case DATA_PACKET :
nodedata->data_rx++;
if ((header->dst != BROADCAST_ADDR) && (header->dst != c->node) ) {
forward(c, packet);
return;
}
while (i--) {
call_t c_up = {up->elts[i], c->node, c->entity};
packet_t *packet_up;
if (i > 0) {
packet_up = packet_clone(packet);
} else {
packet_up = packet;
}
RX(&c_up, packet_up);
}
break;
default :
break;
}
return;
}
void FPURegCache::BindToRegister(const int i, bool doLoad, bool makeDirty) {
_assert_msg_(DYNA_REC, !regs[i].location.IsImm(), "WTF - load - imm");
if (!regs[i].away) {
// Reg is at home in the memory register file. Let's pull it out.
X64Reg xr = GetFreeXReg();
_assert_msg_(DYNA_REC, xr < NUM_X_FPREGS, "WTF - load - invalid reg");
xregs[xr].mipsReg = i;
xregs[xr].dirty = makeDirty;
OpArg newloc = ::Gen::R(xr);
if (doLoad) {
if (!regs[i].location.IsImm() && (regs[i].location.offset & 0x3)) {
PanicAlert("WARNING - misaligned fp register location %i", i);
}
emit->MOVSS(xr, regs[i].location);
}
regs[i].location = newloc;
regs[i].away = true;
} else {
// There are no immediates in the FPR reg file, so we already had this in a register. Make dirty as necessary.
xregs[RX(i)].dirty |= makeDirty;
_assert_msg_(DYNA_REC, regs[i].location.IsSimpleReg(), "not loaded and not simple.");
}
}
DWORD getXSkillBtn() {return RX(posXUnassignSkillBtn<0? 0x243 : posXUnassignSkillBtn);}
int
assemble_security_parameters(connection_t *conn, ccb_t *ccb, pdu_t *rx_pdu,
pdu_t *tx_pdu)
{
negotiation_state_t *state = (negotiation_state_t *) ccb->temp_data;
iscsi_login_parameters_t *par = conn->login_par;
negotiation_parameter_t rxp, *cpar;
uint8_t *rxpars;
int rc, next;
uint8_t identifier = 0;
uint8_t *challenge = NULL;
int challenge_size = 0;
uint8_t *response = NULL;
int response_size = 0;
state->num_pars = 0;
next = 0;
rxpars = (uint8_t *) rx_pdu->temp_data;
if (rxpars == NULL) {
DEBOUT(("No received parameters!\n"));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
/* Note: There are always at least 2 extra bytes past temp_data_len */
rxpars[rx_pdu->temp_data_len] = '\0';
rxpars[rx_pdu->temp_data_len + 1] = '\0';
while (*rxpars) {
if ((rxpars = get_parameter(rxpars, &rxp)) == NULL) {
DEBOUT(("get_parameter returned error\n"));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
state->kflags[rxp.key] |= NS_RECEIVED;
switch (rxp.key) {
case K_AuthMethod:
if (state->auth_state != AUTH_INITIAL) {
DEBOUT(("AuthMethod received, auth_state = %d\n",
state->auth_state));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
/* Note: if the selection is None, we shouldn't be here,
* the target should have transited the state to op-neg.
*/
if (rxp.val.nval[0] != ISCSI_AUTH_CHAP) {
DEBOUT(("AuthMethod isn't CHAP (%d)\n", rxp.val.nval[0]));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
state->auth_state = AUTH_METHOD_SELECTED;
state->auth_alg = rxp.val.nval[0];
break;
case K_Auth_CHAP_Algorithm:
if (state->auth_state != AUTH_CHAP_ALG_SENT ||
rxp.val.nval[0] != 5) {
DEBOUT(("Bad algorithm, auth_state = %d, alg %d\n",
state->auth_state, rxp.val.nval[0]));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
break;
case K_Auth_CHAP_Challenge:
if (state->auth_state != AUTH_CHAP_ALG_SENT || !rxp.list_num) {
DEBOUT(("Bad Challenge, auth_state = %d, len %d\n",
state->auth_state, rxp.list_num));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
challenge = rxp.val.sval;
challenge_size = rxp.list_num;
break;
case K_Auth_CHAP_Identifier:
if (state->auth_state != AUTH_CHAP_ALG_SENT) {
DEBOUT(("Bad ID, auth_state = %d, id %d\n",
state->auth_state, rxp.val.nval[0]));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
identifier = (uint8_t) rxp.val.nval[0];
break;
case K_Auth_CHAP_Name:
if (state->auth_state != AUTH_CHAP_RSP_SENT) {
DEBOUT(("Bad Name, auth_state = %d, name <%s>\n",
state->auth_state, rxp.val.sval));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
/* what do we do with the name?? */
break;
case K_Auth_CHAP_Response:
if (state->auth_state != AUTH_CHAP_RSP_SENT) {
DEBOUT(("Bad Response, auth_state = %d, size %d\n",
state->auth_state, rxp.list_num));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
response = rxp.val.sval;
response_size = rxp.list_num;
if (response_size != CHAP_MD5_SIZE)
return ISCSI_STATUS_NEGOTIATION_ERROR;
break;
default:
rc = eval_parameter(conn, state, &rxp);
if (rc)
return rc;
break;
}
}
switch (state->auth_state) {
case AUTH_INITIAL:
DEBOUT(("Didn't receive Method\n"));
return ISCSI_STATUS_NEGOTIATION_ERROR;
case AUTH_METHOD_SELECTED:
set_key_n(state, K_Auth_CHAP_Algorithm, 5);
state->auth_state = AUTH_CHAP_ALG_SENT;
next = -1;
break;
case AUTH_CHAP_ALG_SENT:
if (!RX(state, K_Auth_CHAP_Algorithm) ||
!RX(state, K_Auth_CHAP_Identifier) ||
!RX(state, K_Auth_CHAP_Challenge)) {
DEBOUT(("Didn't receive all parameters\n"));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
set_key_s(state, K_Auth_CHAP_Name, state->user_name);
chap_md5_response(state->temp_buf, identifier, state->password,
challenge, challenge_size);
cpar = set_key_s(state, K_Auth_CHAP_Response, state->temp_buf);
if (cpar != NULL)
cpar->list_num = CHAP_MD5_SIZE;
if (par->auth_info.mutual_auth) {
if (!state->target_password[0]) {
DEBOUT(("No target password with mutual authentication!\n"));
return ISCSI_STATUS_PARAMETER_MISSING;
}
cprng_strong(kern_cprng,
&state->temp_buf[CHAP_MD5_SIZE],
CHAP_CHALLENGE_LEN + 1, 0);
set_key_n(state, K_Auth_CHAP_Identifier,
state->temp_buf[CHAP_MD5_SIZE]);
cpar = set_key_s(state, K_Auth_CHAP_Challenge,
&state->temp_buf[CHAP_MD5_SIZE + 1]);
if (cpar != NULL)
cpar->list_num = CHAP_CHALLENGE_LEN;
next = -1;
}
state->auth_state = AUTH_CHAP_RSP_SENT;
break;
case AUTH_CHAP_RSP_SENT:
/* we can only be here for mutual authentication */
if (!par->auth_info.mutual_auth || response == NULL) {
DEBOUT(("Mutual authentication not requested\n"));
return ISCSI_STATUS_NEGOTIATION_ERROR;
}
chap_md5_response(state->temp_buf,
state->temp_buf[CHAP_MD5_SIZE],
state->password,
&state->temp_buf[CHAP_MD5_SIZE + 1],
CHAP_CHALLENGE_LEN);
if (memcmp(state->temp_buf, response, response_size)) {
DEBOUT(("Mutual authentication mismatch\n"));
return ISCSI_STATUS_AUTHENTICATION_FAILED;
}
break;
default:
break;
}
complete_pars(state, tx_pdu);
return next;
}
DWORD getXTakeGoldBtn() {return RX(posXTakeGoldBtn<0? 0x105 : posXTakeGoldBtn);}
DWORD getXPutGoldBtn() {return RX(posXPutGoldBtn<0? 0x1C : posXPutGoldBtn);}
DWORD getXNextIndexBtn() {return RX(posXNextIndexBtn<0? D2GetResolution()?0xC0:0xEF : posXNextIndexBtn);}//217:SEL_X(0x128, 0xC0, 0xEF, 0xC0));}
DWORD getXPreviousIndexBtn() {return RX(posXPreviousIndexBtn<0 ? D2GetResolution()?0x60:0x8F :posXPreviousIndexBtn);}//73:SEL_X(0x18, 0x60, 0x8F, 0x60));}
DWORD getXSharedBtn() {return RX(posXSharedBtn<0 ? D2GetResolution()?0x10:0x6F :posXSharedBtn);}//17:SEL_X(0xE3, 0xE3, 0x6F, 0x10));}//0xD8
DWORD getXNextBtn() {return RX(posXNextBtn<0 ? D2GetResolution()?0xA0:0xCF :posXNextBtn);}//?169:SEL_X(0x63, 0x63, 0xCF, 0xA0));}
DWORD getXPreviousBtn() {return RX(posXPreviousBtn<0? D2GetResolution()?0x80:0xAF : posXPreviousBtn);}
void STDCALL printNewStatsPageTwo(int currentPage)
{
if (!D2isLODGame()) return D2PrintStatsPage();
WCHAR text[BUFSIZE];
LPWSTR lpText;
bDontPrintBorder = false;
Unit* ptChar = D2GetClientPlayer();
d2_assert(!ptChar, "Printing stats page : no character selected",__FILE__,__LINE__);
d2_assert(ptChar->nUnitType != UNIT_PLAYER, "Printing stats page : bad unit type",__FILE__,__LINE__);
//Init data for print image
sDrawImageInfo data;
ZeroMemory(&data,sizeof(data));
//print background
fillRect(RX(0),RY(480),320,432,0,5);//552
setImage(&data, newStatsInterfaceImages);
setFrame(&data, 0);
D2PrintImage(&data, RX(0), RY(224), -1, 5, 0);
setFrame(&data, 1);
D2PrintImage(&data, RX(256),RY(224), -1, 5, 0);//256
setFrame(&data, 2);
D2PrintImage(&data, RX(0), RY(48), -1, 5, 0);//432
setFrame(&data, 3);
D2PrintImage(&data, RX(256),RY(48), -1, 5, 0);
D2SetFont(1);
for (int i=0; i<nbStatsInterface; i++)
manageStatLine(ptChar, &statsInterface[i], currentPage, text);
/*
// DWORD x,y;
// DWORD curValue;
// CharStatsBIN* charStats = D2GetCharStatsBIN(ptChar->nPlayerClass);
// DifficultyLevelsBIN* difficultyLevels = D2GetDifficultyLevelsBIN (D2GetDifficultyLevel());
//print deadly Strike / Critical Strike
x=RX(25);
y=RY(445);
Unit* ptItem = D2GetSkillItem(ptChar);
DWORD cs = ptItem ? D2GetCriticalStrikeFromMasteries(ptChar,ptItem,0,2) : 0;
cs = cs>100?100:cs;
cs += D2GetPlayerStat(ptChar, STATS_PASSIVE_CRITICAL_STRIKE, 0)*(100-cs)/100;
cs = cs>100?100:cs;
//SkillDescBIN* skilldesc = SgptDataTables->skilldesc + 9;
LPWSTR lpCS = D2GetStringFromIndex(skilldesc->strNameID);
lpText = D2GetStringFromIndex(getDescStrPos(STATS_ITEM_DEADLYSTRIKE));
curValue = D2GetPlayerStat(ptChar, STATS_ITEM_DEADLYSTRIKE, 0);
cs += curValue*(100-cs)/100;
curValue = cs>100?100:cs;
swprintf(text,L"%i%% %s/%s",curValue,lpCS,lpText);
D2SetFont(1);
D2SetFont( D2GetPixelLen(text)>0x110 ? 6 : 1);
D2PrintString(text, x, y, WHITE, 0);
*/
//print background previous/next page buttons
setImage(&data, statsBackgroundImages);
setFrame(&data, D2GetResolution()?1:0);
D2PrintImage(&data, getXPreviousPageBtn()-7, getYPreviousPageBtn()+8, -1, 5, 0);
//print button close
setImage(&data, D2LoadBuySelBtn());
setFrame(&data, 10 + isDownBtn.close);
D2PrintImage(&data, getXCloseBtn(), getYCloseBtn(), -1, 5, 0);
//print previous page button
setFrame(&data, 12 + isDownBtn.previousPage);
D2PrintImage(&data, getXPreviousPageBtn(), getYPreviousPageBtn(), -1, 5, 0);
//print next page button
setFrame(&data, 14 + isDownBtn.nextPage);
D2PrintImage(&data, getXNextPageBtn(), getYNextPageBtn(), -1, 5, 0);
//////////////////// POPUP PRINTING ////////////////////
//set MouseX & MouseY
DWORD mx = D2GetMouseX();
DWORD my = D2GetMouseY();
D2SetFont(1);
if (isOnCloseBtn(mx,my)) // print popup "close"
{
D2PrintPopup(D2GetStringFromIndex(0x1030), getXCloseBtn()+getLCloseBtn()/2, getYCloseBtn()-getHCloseBtn(), WHITE, 1);
}
else if (isOnPreviousPageBtn(mx,my)) //print popup "previous page"
{
lpText = getLocalString(STR_PREVIOUS_PAGE);
D2PrintPopup(lpText, getXPreviousPageBtn()+getLPreviousPageBtn()/2, getYPreviousPageBtn()-getHPreviousPageBtn(), WHITE, 1);
}
else if (isOnNextPageBtn(mx,my)) //print popup "next page"
{
lpText = getLocalString(STR_NEXT_PAGE);
D2PrintPopup(lpText, getXNextPageBtn()+getLNextPageBtn()/2, getYNextPageBtn()-getHNextPageBtn(), WHITE, 1);
}
}
void MyWidget::MarchingCubes() {
Vector **triangles = new Vector*[5];
for (int i = 0; i < 5; i++) {
triangles[i] = new Vector[3];
}
Matrix T(4, 4);
T.Diag(1);
T(0, 3) = Tx + 200;
T(1, 3) = Ty + 150;
T(2, 3) = Tz;
Matrix Sc(4, 4);
Sc(0, 0) = ScX;
Sc(1, 1) = ScY;
Sc(2, 2) = ScZ;
Sc(3, 3) = 1;
Matrix RX(4, 4);
RX.Diag(1);
RX(1, 1) = cos(AlfaX);
RX(1, 2) = sin(AlfaX);
RX(2, 1) = -sin(AlfaX);
RX(2, 2) = cos(AlfaX);
Matrix RY(4, 4);
RY.Diag(1);
RY(0, 0) = cos(AlfaY);
RY(0, 2) = -sin(AlfaY);
RY(2, 0) = sin(AlfaY);
RY(2, 2) = cos(AlfaY);
Matrix RZ(4, 4);
RZ.Diag(1);
RZ(0, 0) = cos(AlfaZ);
RZ(0, 1) = sin(AlfaZ);
RZ(1, 0) = -sin(AlfaZ);
RZ(1, 1) = cos(AlfaZ);
Matrix m = T.multi(Sc.multi(RX.multi(RY.multi(RZ))));
T.free();
Sc.free();
RX.free();
RY.free();
RZ.free();
Matrix p;
for (int x = _S; x < fR2; x += _S) {
for (int y = _S; y < fR2; y += _S) {
for (int z = _S; z < fR2; z += _S) {
int n = Polygonise(x, y, z, 1, triangles);
for (int i = 0; i < n; i++) {
Vector tab[3];
for (int j = 0; j < 3; j++) {
p = m.multi(triangles[i][j]);
tab[j] = Vector(p(X, 0), p(Y, 0), p(Z, 0));
}
Triangle(_bitsDest, tab[0], tab[1], tab[2]);
tab[0].free();
tab[1].free();
tab[2].free();
}
}
}
}
m.free();
p.free();
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 3; j++) {
triangles[i][j].free();
}
}
}