bool ObjectManager::load_base(ROBJECT_TYPE::ENUM type, SlkTable& table)
{
switch (type)
{
case ROBJECT_TYPE::UNIT:
load_unit(table);
break;
case ROBJECT_TYPE::ITEM:
load_item(table);
break;
case ROBJECT_TYPE::DESTRUCTABLE:
load_destructable(table);
break;
case ROBJECT_TYPE::BUFF:
load_buff(table);
break;
case ROBJECT_TYPE::DOODAD:
load_doodad(table);
break;
case ROBJECT_TYPE::ABILITY:
load_ability(table);
break;
case ROBJECT_TYPE::UPGRADE:
load_upgrde(table);
break;
default:
assert(false);
return false;
}
return true;
}
void LIRItem::load_nonconstant() {
if (is_constant()) {
dont_load_item();
} else {
load_item();
}
}
void LIRItem::load_nonconstant() {
LIR_Opr r = value()->operand();
if (r->is_constant()) {
_result = r;
} else {
load_item();
}
}
void Project::load_item_children(ProjectItem *item, DomElement dom_items)
{
DomElement cur = dom_items.get_first_child_element();
while (!cur.is_null())
{
item->add(load_item(cur));
cur = cur.get_next_sibling_element();
}
}
void LIRItem::load_nonconstant() {
LIR_Opr r = value()->operand();
if (_gen->can_inline_as_constant(value())) {
if (!r->is_constant()) {
r = LIR_OprFact::value_type(value()->type());
}
_result = r;
} else {
load_item();
}
}
// Item will be loaded into a byte register; Intel only
void LIRItem::load_byte_item() {
load_item();
LIR_Opr res = result();
if (!res->is_virtual() || !_gen->is_vreg_flag_set(res, LIRGenerator::byte_reg)) {
// make sure that it is a byte register
assert(!value()->type()->is_float() && !value()->type()->is_double(),
"can't load floats in byte register");
LIR_Opr reg = _gen->rlock_byte(T_BYTE);
__ move(res, reg);
_result = reg;
}
}
int Credits::init(Config conf, std::string arg)
{
/*
* Load image texture:
*/
if (!m_img_texture.loadFromFile(get_data_path(DATALOADER_TYPE_IMG, "credits.png")))
return 1;
m_img_texture.setSmooth(true);
m_img.setTexture(m_img_texture);
/*
* Load fonts:
*/
if (!m_font1.loadFromFile(get_data_path(DATALOADER_TYPE_FONT, "Vollkorn-Bold.ttf")))
return 1;
if (!m_font2.loadFromFile(get_data_path(DATALOADER_TYPE_FONT, "Vollkorn-Regular.ttf")))
return 1;
/*
* Init header:
*/
m_header.setFont(m_font1);
m_header.setColor(sf::Color::Red);
/*
* Init text:
*/
m_text.setFont(m_font2);
m_text.setColor(sf::Color::Red);
/*
* Init sign:
*/
m_sign.setFont(m_font1);
m_sign.setColor(sf::Color(254, 42, 53));
/*
* Load standard text:
*/
load_item(-1);
/*
* Load capsaicin dev logo texture:
*/
if (!m_cdev_texture.loadFromFile(get_data_path(DATALOADER_TYPE_IMG, "cdev.png")))
return 1;
m_cdev_texture.setSmooth(true);
m_cdev.setTexture(m_cdev_texture);
return 0;
}
void Credits::process_event(sf::Event event, int mouse_x, int mouse_y, EventProcessorReturn *ret)
{
/*
* Variable declarations:
*/
int i;
switch (event.type)
{
case sf::Event::KeyPressed:
switch (event.key.code)
{
case sf::Keyboard::Escape:
ret->set_gamemode(1);
break;
}
break;
case sf::Event::MouseMoved:
m_item_over = -1;
for (i=0; i < CREDITS_COUNT; i++)
{
if (mouse_x >= m_hovert_x1[i] &&
mouse_x <= m_hovert_x2[i] &&
mouse_y >= m_credits_yoffset+m_hovert_y1[i] &&
mouse_y <= m_credits_yoffset+m_hovert_y2[i])
{
m_item_over = i;
};
}
if (m_item_over != m_item_loaded)
load_item(m_item_over);
break;
case sf::Event::MouseButtonPressed:
switch (event.mouseButton.button)
{
case sf::Mouse::Left:
if (m_item_loaded == 5)
ret->set_gamemode(1); // go to main menu
break;
}
break;
}
}
static int load_loop(t_bunny_ini *ini,
t_objs *objs)
{
t_bunny_ini_scope *scope;
int x;
if ((scope = bunny_ini_first(ini)) == NULL)
return (1);
load_def(scope, objs);
scope = bunny_ini_next(ini, scope);
x = 0;
while (scope != NULL && x < objs->nb)
{
load_item(scope, &((objs->objs)[x]));
scope = bunny_ini_next(ini, scope);
x += 1;
}
return (0);
}
struct assy *load_assy(FILE *f, char **hptrs, int nh, struct item *i, struct item **ra)
{
struct assy *a = (struct assy *)malloc(sizeof(struct assy));
struct assy *b;
char *part = 0;
a->next = 0;
a->header = i;
a->items = 0;
if (i)
{
part = get_field(i, col_pn);
/* printf("Loading part %s\n",part); */
}
i = load_item(f, hptrs, nh);
if (i && !part) /* For first one */
{
part = get_field(i, col_parent_assy);
/* printf("Loading part %s\n",part); */
a->header = (struct item *)malloc(sizeof(struct item));
a->header->next = 0;
a->header->fields = (struct field *)malloc(sizeof(struct field));
a->header->fields->next = 0;
a->header->fields->name = strdup(col_pn);
a->header->fields->value = strdup(part);
}
/* show_item(i); */
while (i)
{
char *ip = get_field(i, col_parent_assy);
/* Part of this assy? */
if (strcmp(ip, part))
break;
b = load_assy(f, hptrs, nh, i, &i);
b->next = a->items;
a->items = b;
}
*ra = i;
return a;
}
void Room::load(InputStream *stream, int notebook_version, NaturalLanguage language) {
if (stream->get() != ROOM_MARKER) {
log(S(IDS_BAD_ROOM_IN_CITY_FILE),FALSE,TRUE);
return;
};
Sprite *saved_wall_decoration = load_item(stream,notebook_version,language);
if (saved_wall_decoration != NULL) {
saved_wall_decoration->recursively_propagate_changes(); // new on 160601 to get offsets right
set_wall_decoration_sprite(saved_wall_decoration);
// Sprites *remaining = saved_wall_decoration->pointer_to_followers();
// while (remaining != NULL) {
// Sprite *sprite = remaining->first();
// position_and_add_to_wall(Sprite *wall_remote, Sprite *addition, Room *room)
};
Sprites *floor_items = load_items(stream,notebook_version,language);
if (floor_items != NULL) {
add_items(floor_items);
floor_items->recursively_propagate_changes();
floor_items->activate();
floor_items->remove_all();
delete floor_items;
};
};
void
load_activity::execute(data_board& board)
{/*{{{*/
_status_control.move_to(exed);
outputer::shared_ptr outer = board.classify_outputer(_out_path, _out_filename);
try
{
size_t count=1;
for(; (!_stream_in->eof()) && (count<= _proc_count); ++count)
{
load_item(count,outer);
}
if(_stream_in->fail())
_logger.errorStream()<<" file stream error : "<< _stream_in->rdstate();
if(_logger.isDebugEnabled())
_logger.debugStream()<<" log item : "<< count <<" have loaded";
}
catch(...)
{
_logger.errorStream()<<" unkonw error happend " ;
}
outer->haved_output();
}/*}}}*/
void CodLinkCanvas::history_load(QBuffer & b) {
ArrowCanvas::history_load(b);
dirs = (CodDirsCanvas *) load_item(b);
}
void LIRItem::load_byte_item() {
// byte loads use same registers as other loads
load_item();
}
