Xadhoom
5 years ago
committed by
Anders Jenbo
7 changed files with 620 additions and 3 deletions
@ -0,0 +1,377 @@
|
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (C) 2017 okdshin |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
*/ |
||||
#ifndef PICOSHA2_H |
||||
#define PICOSHA2_H |
||||
// picosha2:20140213
|
||||
|
||||
#ifndef PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR |
||||
#define PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR \ |
||||
1048576 //=1024*1024: default is 1MB memory
|
||||
#endif |
||||
|
||||
#include <algorithm> |
||||
#include <cassert> |
||||
#include <iterator> |
||||
#include <sstream> |
||||
#include <vector> |
||||
#include <fstream> |
||||
namespace picosha2 { |
||||
typedef unsigned long word_t; |
||||
typedef unsigned char byte_t; |
||||
|
||||
static const size_t k_digest_size = 32; |
||||
|
||||
namespace detail { |
||||
inline byte_t mask_8bit(byte_t x) { return x & 0xff; } |
||||
|
||||
inline word_t mask_32bit(word_t x) { return x & 0xffffffff; } |
||||
|
||||
const word_t add_constant[64] = { |
||||
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, |
||||
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, |
||||
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, |
||||
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, |
||||
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, |
||||
0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, |
||||
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, |
||||
0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, |
||||
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, |
||||
0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, |
||||
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2}; |
||||
|
||||
const word_t initial_message_digest[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, |
||||
0xa54ff53a, 0x510e527f, 0x9b05688c, |
||||
0x1f83d9ab, 0x5be0cd19}; |
||||
|
||||
inline word_t ch(word_t x, word_t y, word_t z) { return (x & y) ^ ((~x) & z); } |
||||
|
||||
inline word_t maj(word_t x, word_t y, word_t z) { |
||||
return (x & y) ^ (x & z) ^ (y & z); |
||||
} |
||||
|
||||
inline word_t rotr(word_t x, std::size_t n) { |
||||
assert(n < 32); |
||||
return mask_32bit((x >> n) | (x << (32 - n))); |
||||
} |
||||
|
||||
inline word_t bsig0(word_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); } |
||||
|
||||
inline word_t bsig1(word_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); } |
||||
|
||||
inline word_t shr(word_t x, std::size_t n) { |
||||
assert(n < 32); |
||||
return x >> n; |
||||
} |
||||
|
||||
inline word_t ssig0(word_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3); } |
||||
|
||||
inline word_t ssig1(word_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10); } |
||||
|
||||
template <typename RaIter1, typename RaIter2> |
||||
void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last) { |
||||
assert(first + 64 == last); |
||||
static_cast<void>(last); // for avoiding unused-variable warning
|
||||
word_t w[64]; |
||||
std::fill(w, w + 64, 0); |
||||
for (std::size_t i = 0; i < 16; ++i) { |
||||
w[i] = (static_cast<word_t>(mask_8bit(*(first + i * 4))) << 24) | |
||||
(static_cast<word_t>(mask_8bit(*(first + i * 4 + 1))) << 16) | |
||||
(static_cast<word_t>(mask_8bit(*(first + i * 4 + 2))) << 8) | |
||||
(static_cast<word_t>(mask_8bit(*(first + i * 4 + 3)))); |
||||
} |
||||
for (std::size_t i = 16; i < 64; ++i) { |
||||
w[i] = mask_32bit(ssig1(w[i - 2]) + w[i - 7] + ssig0(w[i - 15]) + |
||||
w[i - 16]); |
||||
} |
||||
|
||||
word_t a = *message_digest; |
||||
word_t b = *(message_digest + 1); |
||||
word_t c = *(message_digest + 2); |
||||
word_t d = *(message_digest + 3); |
||||
word_t e = *(message_digest + 4); |
||||
word_t f = *(message_digest + 5); |
||||
word_t g = *(message_digest + 6); |
||||
word_t h = *(message_digest + 7); |
||||
|
||||
for (std::size_t i = 0; i < 64; ++i) { |
||||
word_t temp1 = h + bsig1(e) + ch(e, f, g) + add_constant[i] + w[i]; |
||||
word_t temp2 = bsig0(a) + maj(a, b, c); |
||||
h = g; |
||||
g = f; |
||||
f = e; |
||||
e = mask_32bit(d + temp1); |
||||
d = c; |
||||
c = b; |
||||
b = a; |
||||
a = mask_32bit(temp1 + temp2); |
||||
} |
||||
*message_digest += a; |
||||
*(message_digest + 1) += b; |
||||
*(message_digest + 2) += c; |
||||
*(message_digest + 3) += d; |
||||
*(message_digest + 4) += e; |
||||
*(message_digest + 5) += f; |
||||
*(message_digest + 6) += g; |
||||
*(message_digest + 7) += h; |
||||
for (std::size_t i = 0; i < 8; ++i) { |
||||
*(message_digest + i) = mask_32bit(*(message_digest + i)); |
||||
} |
||||
} |
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename InIter> |
||||
void output_hex(InIter first, InIter last, std::ostream& os) { |
||||
os.setf(std::ios::hex, std::ios::basefield); |
||||
while (first != last) { |
||||
os.width(2); |
||||
os.fill('0'); |
||||
os << static_cast<unsigned int>(*first); |
||||
++first; |
||||
} |
||||
os.setf(std::ios::dec, std::ios::basefield); |
||||
} |
||||
|
||||
template <typename InIter> |
||||
void bytes_to_hex_string(InIter first, InIter last, std::string& hex_str) { |
||||
std::ostringstream oss; |
||||
output_hex(first, last, oss); |
||||
hex_str.assign(oss.str()); |
||||
} |
||||
|
||||
template <typename InContainer> |
||||
void bytes_to_hex_string(const InContainer& bytes, std::string& hex_str) { |
||||
bytes_to_hex_string(bytes.begin(), bytes.end(), hex_str); |
||||
} |
||||
|
||||
template <typename InIter> |
||||
std::string bytes_to_hex_string(InIter first, InIter last) { |
||||
std::string hex_str; |
||||
bytes_to_hex_string(first, last, hex_str); |
||||
return hex_str; |
||||
} |
||||
|
||||
template <typename InContainer> |
||||
std::string bytes_to_hex_string(const InContainer& bytes) { |
||||
std::string hex_str; |
||||
bytes_to_hex_string(bytes, hex_str); |
||||
return hex_str; |
||||
} |
||||
|
||||
class hash256_one_by_one { |
||||
public: |
||||
hash256_one_by_one() { init(); } |
||||
|
||||
void init() { |
||||
buffer_.clear(); |
||||
std::fill(data_length_digits_, data_length_digits_ + 4, 0); |
||||
std::copy(detail::initial_message_digest, |
||||
detail::initial_message_digest + 8, h_); |
||||
} |
||||
|
||||
template <typename RaIter> |
||||
void process(RaIter first, RaIter last) { |
||||
add_to_data_length(static_cast<word_t>(std::distance(first, last))); |
||||
std::copy(first, last, std::back_inserter(buffer_)); |
||||
std::size_t i = 0; |
||||
for (; i + 64 <= buffer_.size(); i += 64) { |
||||
detail::hash256_block(h_, buffer_.begin() + i, |
||||
buffer_.begin() + i + 64); |
||||
} |
||||
buffer_.erase(buffer_.begin(), buffer_.begin() + i); |
||||
} |
||||
|
||||
void finish() { |
||||
byte_t temp[64]; |
||||
std::fill(temp, temp + 64, 0); |
||||
std::size_t remains = buffer_.size(); |
||||
std::copy(buffer_.begin(), buffer_.end(), temp); |
||||
temp[remains] = 0x80; |
||||
|
||||
if (remains > 55) { |
||||
std::fill(temp + remains + 1, temp + 64, 0); |
||||
detail::hash256_block(h_, temp, temp + 64); |
||||
std::fill(temp, temp + 64 - 4, 0); |
||||
} else { |
||||
std::fill(temp + remains + 1, temp + 64 - 4, 0); |
||||
} |
||||
|
||||
write_data_bit_length(&(temp[56])); |
||||
detail::hash256_block(h_, temp, temp + 64); |
||||
} |
||||
|
||||
template <typename OutIter> |
||||
void get_hash_bytes(OutIter first, OutIter last) const { |
||||
for (const word_t* iter = h_; iter != h_ + 8; ++iter) { |
||||
for (std::size_t i = 0; i < 4 && first != last; ++i) { |
||||
*(first++) = detail::mask_8bit( |
||||
static_cast<byte_t>((*iter >> (24 - 8 * i)))); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private: |
||||
void add_to_data_length(word_t n) { |
||||
word_t carry = 0; |
||||
data_length_digits_[0] += n; |
||||
for (std::size_t i = 0; i < 4; ++i) { |
||||
data_length_digits_[i] += carry; |
||||
if (data_length_digits_[i] >= 65536u) { |
||||
carry = data_length_digits_[i] >> 16; |
||||
data_length_digits_[i] &= 65535u; |
||||
} else { |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
void write_data_bit_length(byte_t* begin) { |
||||
word_t data_bit_length_digits[4]; |
||||
std::copy(data_length_digits_, data_length_digits_ + 4, |
||||
data_bit_length_digits); |
||||
|
||||
// convert byte length to bit length (multiply 8 or shift 3 times left)
|
||||
word_t carry = 0; |
||||
for (std::size_t i = 0; i < 4; ++i) { |
||||
word_t before_val = data_bit_length_digits[i]; |
||||
data_bit_length_digits[i] <<= 3; |
||||
data_bit_length_digits[i] |= carry; |
||||
data_bit_length_digits[i] &= 65535u; |
||||
carry = (before_val >> (16 - 3)) & 65535u; |
||||
} |
||||
|
||||
// write data_bit_length
|
||||
for (int i = 3; i >= 0; --i) { |
||||
(*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8); |
||||
(*begin++) = static_cast<byte_t>(data_bit_length_digits[i]); |
||||
} |
||||
} |
||||
std::vector<byte_t> buffer_; |
||||
word_t data_length_digits_[4]; // as 64bit integer (16bit x 4 integer)
|
||||
word_t h_[8]; |
||||
}; |
||||
|
||||
inline void get_hash_hex_string(const hash256_one_by_one& hasher, |
||||
std::string& hex_str) { |
||||
byte_t hash[k_digest_size]; |
||||
hasher.get_hash_bytes(hash, hash + k_digest_size); |
||||
return bytes_to_hex_string(hash, hash + k_digest_size, hex_str); |
||||
} |
||||
|
||||
inline std::string get_hash_hex_string(const hash256_one_by_one& hasher) { |
||||
std::string hex_str; |
||||
get_hash_hex_string(hasher, hex_str); |
||||
return hex_str; |
||||
} |
||||
|
||||
namespace impl { |
||||
template <typename RaIter, typename OutIter> |
||||
void hash256_impl(RaIter first, RaIter last, OutIter first2, OutIter last2, int, |
||||
std::random_access_iterator_tag) { |
||||
hash256_one_by_one hasher; |
||||
// hasher.init();
|
||||
hasher.process(first, last); |
||||
hasher.finish(); |
||||
hasher.get_hash_bytes(first2, last2); |
||||
} |
||||
|
||||
template <typename InputIter, typename OutIter> |
||||
void hash256_impl(InputIter first, InputIter last, OutIter first2, |
||||
OutIter last2, int buffer_size, std::input_iterator_tag) { |
||||
std::vector<byte_t> buffer(buffer_size); |
||||
hash256_one_by_one hasher; |
||||
// hasher.init();
|
||||
while (first != last) { |
||||
int size = buffer_size; |
||||
for (int i = 0; i != buffer_size; ++i, ++first) { |
||||
if (first == last) { |
||||
size = i; |
||||
break; |
||||
} |
||||
buffer[i] = *first; |
||||
} |
||||
hasher.process(buffer.begin(), buffer.begin() + size); |
||||
} |
||||
hasher.finish(); |
||||
hasher.get_hash_bytes(first2, last2); |
||||
} |
||||
} |
||||
|
||||
template <typename InIter, typename OutIter> |
||||
void hash256(InIter first, InIter last, OutIter first2, OutIter last2, |
||||
int buffer_size = PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR) { |
||||
picosha2::impl::hash256_impl( |
||||
first, last, first2, last2, buffer_size, |
||||
typename std::iterator_traits<InIter>::iterator_category()); |
||||
} |
||||
|
||||
template <typename InIter, typename OutContainer> |
||||
void hash256(InIter first, InIter last, OutContainer& dst) { |
||||
hash256(first, last, dst.begin(), dst.end()); |
||||
} |
||||
|
||||
template <typename InContainer, typename OutIter> |
||||
void hash256(const InContainer& src, OutIter first, OutIter last) { |
||||
hash256(src.begin(), src.end(), first, last); |
||||
} |
||||
|
||||
template <typename InContainer, typename OutContainer> |
||||
void hash256(const InContainer& src, OutContainer& dst) { |
||||
hash256(src.begin(), src.end(), dst.begin(), dst.end()); |
||||
} |
||||
|
||||
template <typename InIter> |
||||
void hash256_hex_string(InIter first, InIter last, std::string& hex_str) { |
||||
byte_t hashed[k_digest_size]; |
||||
hash256(first, last, hashed, hashed + k_digest_size); |
||||
std::ostringstream oss; |
||||
output_hex(hashed, hashed + k_digest_size, oss); |
||||
hex_str.assign(oss.str()); |
||||
} |
||||
|
||||
template <typename InIter> |
||||
std::string hash256_hex_string(InIter first, InIter last) { |
||||
std::string hex_str; |
||||
hash256_hex_string(first, last, hex_str); |
||||
return hex_str; |
||||
} |
||||
|
||||
inline void hash256_hex_string(const std::string& src, std::string& hex_str) { |
||||
hash256_hex_string(src.begin(), src.end(), hex_str); |
||||
} |
||||
|
||||
template <typename InContainer> |
||||
void hash256_hex_string(const InContainer& src, std::string& hex_str) { |
||||
hash256_hex_string(src.begin(), src.end(), hex_str); |
||||
} |
||||
|
||||
template <typename InContainer> |
||||
std::string hash256_hex_string(const InContainer& src) { |
||||
return hash256_hex_string(src.begin(), src.end()); |
||||
} |
||||
template<typename OutIter>void hash256(std::ifstream& f, OutIter first, OutIter last){ |
||||
hash256(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>(), first,last); |
||||
|
||||
} |
||||
}// namespace picosha2
|
||||
#endif // PICOSHA2_H
|
||||
@ -0,0 +1,232 @@
|
||||
#include <gtest/gtest.h> |
||||
#include "picosha2.h" |
||||
#include <fstream> |
||||
#include <vector> |
||||
#include <cstdio> |
||||
#include "all.h" |
||||
#include "paths.h" |
||||
|
||||
using namespace dvl; |
||||
|
||||
int spelldat_vanilla[] = {0, 1, 1, 4, 5, -1, 3, 3, 6, -1, 7, 6, 8, 9, |
||||
8, 9, -1, -1, -1, -1, 3, 11, -1, 14, -1, -1, |
||||
-1, -1, -1, 8, 1, 1, -1, 2, 1, 14, 9}; |
||||
|
||||
static void PackItemUnique(PkItemStruct *id, int idx) |
||||
{ |
||||
id->idx = idx; |
||||
id->iCreateInfo = 0x2DE; |
||||
id->bId = 1+2*ITEM_QUALITY_UNIQUE; |
||||
id->bDur = 40; |
||||
id->bMDur = 40; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x1C0C44B0; |
||||
} |
||||
|
||||
static void PackItemStaff(PkItemStruct *id) |
||||
{ |
||||
id->idx = 150; |
||||
id->iCreateInfo = 0x2010; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 75; |
||||
id->bMDur = 75; |
||||
id->bCh = 12; |
||||
id->bMCh = 12; |
||||
id->iSeed = 0x2A15243F; |
||||
} |
||||
|
||||
static void PackItemBow(PkItemStruct *id) |
||||
{ |
||||
id->idx = 145; |
||||
id->iCreateInfo = 0x0814; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 60; |
||||
id->bMDur = 60; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x449D8992; |
||||
} |
||||
|
||||
static void PackItemSword(PkItemStruct *id) |
||||
{ |
||||
id->idx = 122; |
||||
id->iCreateInfo = 0x081E; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 60; |
||||
id->bMDur = 60; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x680FAC02; |
||||
} |
||||
|
||||
static void PackItemRing1(PkItemStruct *id) |
||||
{ |
||||
id->idx = 153; |
||||
id->iCreateInfo = 0xDE; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 0; |
||||
id->bMDur = 0; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x5B41AFA8; |
||||
} |
||||
|
||||
static void PackItemRing2(PkItemStruct *id) |
||||
{ |
||||
id->idx = 153; |
||||
id->iCreateInfo = 0xDE; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 0; |
||||
id->bMDur = 0; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x1E41FEFC; |
||||
} |
||||
|
||||
static void PackItemAmulet(PkItemStruct *id) |
||||
{ |
||||
id->idx = 155; |
||||
id->iCreateInfo = 0xDE; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 0; |
||||
id->bMDur = 0; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x70A0383A; |
||||
} |
||||
|
||||
static void PackItemArmor(PkItemStruct *id) |
||||
{ |
||||
id->idx = 70; |
||||
id->iCreateInfo = 0xDE; |
||||
id->bId = 1+2*ITEM_QUALITY_MAGIC; |
||||
id->bDur = 90; |
||||
id->bMDur = 90; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
id->iSeed = 0x63AAC49B; |
||||
} |
||||
|
||||
static void PackItemFullRejuv(PkItemStruct *id, int i) |
||||
{ |
||||
const Uint32 seeds[] = {0x7C253335, 0x3EEFBFF8, 0x76AFB1A9, 0x38EB45FE, 0x1154E197, 0x5964B644, 0x76B58BEB, 0x002A6E5A}; |
||||
id->idx = ItemMiscIdIdx(IMISC_FULLREJUV); |
||||
id->iSeed = seeds[i]; |
||||
id->iCreateInfo = 0; |
||||
id->bId = 2*ITEM_QUALITY_NORMAL; |
||||
id->bDur = 0; |
||||
id->bMDur = 0; |
||||
id->bCh = 0; |
||||
id->bMCh = 0; |
||||
} |
||||
|
||||
static int PrepareInvSlot(PkPlayerStruct *pPack, int pos, int size, int start=0) |
||||
{ |
||||
static char ret = 0; |
||||
if(start) |
||||
ret = 0; |
||||
++ret; |
||||
if(size == 0) { |
||||
pPack->InvGrid[pos] = ret; |
||||
} else if(size == 1) { |
||||
pPack->InvGrid[pos] = ret; |
||||
pPack->InvGrid[pos-10] = -ret; |
||||
pPack->InvGrid[pos-20] = -ret; |
||||
} else if(size == 2) { |
||||
pPack->InvGrid[pos] = ret; |
||||
pPack->InvGrid[pos+1] = -ret; |
||||
pPack->InvGrid[pos-10] = -ret; |
||||
pPack->InvGrid[pos-10+1] = -ret; |
||||
pPack->InvGrid[pos-20] = -ret; |
||||
pPack->InvGrid[pos-20+1] = -ret; |
||||
} else if(size == 3) { |
||||
pPack->InvGrid[pos] = ret; |
||||
pPack->InvGrid[pos+1] = -ret; |
||||
pPack->InvGrid[pos-10] = -ret; |
||||
pPack->InvGrid[pos-10+1] = -ret; |
||||
} else { |
||||
abort(); |
||||
} |
||||
return ret - 1; |
||||
} |
||||
|
||||
static void PackPlayerTest(PkPlayerStruct *pPack) |
||||
{ |
||||
memset(pPack, 0, 0x4F2); |
||||
pPack->destAction = -1; |
||||
pPack->destParam1 = 0; |
||||
pPack->destParam2 = 0; |
||||
pPack->plrlevel = 0; |
||||
pPack->pExperience = 1583495809; |
||||
pPack->pLevel = 50; |
||||
pPack->px = 75; |
||||
pPack->py = 68; |
||||
pPack->targx = 75; |
||||
pPack->targy = 68; |
||||
pPack->pGold = 0; |
||||
pPack->pStatPts = 0; |
||||
pPack->pDiabloKillLevel = 3; |
||||
for (auto i = 0; i < 40; i++) |
||||
pPack->InvList[i].idx = -1; |
||||
for (auto i = 0; i < 7; i++) |
||||
pPack->InvBody[i].idx = -1; |
||||
for (auto i = 0; i < MAXBELTITEMS; i++) |
||||
PackItemFullRejuv(pPack->SpdList+i, i); |
||||
for (auto i = 1; i < 37; i++) { |
||||
if(spelldat_vanilla[i] != -1) { |
||||
pPack->pMemSpells |= (__int64)1 << (i-1); |
||||
pPack->pSplLvl[i] = 15; |
||||
} |
||||
} |
||||
for (auto i = 0; i < 7; i++) |
||||
pPack->InvBody[i].idx = -1; |
||||
strcpy(pPack->pName, "TestPlayer"); |
||||
pPack->pClass = PC_ROGUE; |
||||
pPack->pBaseStr = 20 + 35; |
||||
pPack->pBaseMag = 15 + 55; |
||||
pPack->pBaseDex = 30 + 220; |
||||
pPack->pBaseVit = 20 + 60; |
||||
pPack->pHPBase = ((20+10)<<6)+((20+10)<<5) + 48*128 + (60<<6); |
||||
pPack->pMaxHPBase = pPack->pHPBase; |
||||
pPack->pManaBase = (15<<6)+(15<<5) + 48*128 + (55<<6); |
||||
pPack->pMaxManaBase = pPack->pManaBase; |
||||
|
||||
PackItemUnique(pPack->InvBody+INVLOC_HEAD, 52); |
||||
PackItemRing1(pPack->InvBody+INVLOC_RING_LEFT); |
||||
PackItemRing2(pPack->InvBody+INVLOC_RING_RIGHT); |
||||
PackItemAmulet(pPack->InvBody+INVLOC_AMULET); |
||||
PackItemArmor(pPack->InvBody+INVLOC_CHEST); |
||||
PackItemBow(pPack->InvBody+INVLOC_HAND_LEFT); |
||||
|
||||
PackItemStaff(pPack->InvList+PrepareInvSlot(pPack, 28, 2, 1)); |
||||
PackItemSword(pPack->InvList+PrepareInvSlot(pPack, 20, 1)); |
||||
|
||||
pPack->_pNumInv = 2; |
||||
} |
||||
|
||||
TEST(Writehero, pfile_write_hero) { |
||||
SetPrefPath("."); |
||||
std::remove("multi_0.sv"); |
||||
|
||||
myplr = 0; |
||||
|
||||
_uiheroinfo info{}; |
||||
strcpy(info.name, "TestPlayer"); |
||||
info.heroclass = PC_ROGUE; |
||||
|
||||
gbVanilla = true; |
||||
gbIsHellfire = false; |
||||
gbIsMultiplayer = true; |
||||
pfile_ui_save_create(&info); |
||||
|
||||
PkPlayerStruct pks; |
||||
PackPlayerTest(&pks); |
||||
UnPackPlayer(&pks, myplr, TRUE); |
||||
pfile_write_hero(); |
||||
std::ifstream f("multi_0.sv", std::ios::binary); |
||||
std::vector<unsigned char> s(picosha2::k_digest_size); |
||||
picosha2::hash256(f, s.begin(), s.end()); |
||||
EXPECT_EQ(picosha2::bytes_to_hex_string(s.begin(), s.end()), |
||||
"08e9807d1281e4273268f4e265757b4429cfec7c3e8b6deb89dfa109d6797b1c"); |
||||
} |
||||
Loading…
Reference in new issue