/**
* eAdventure (formerly <e-Adventure> and <e-Game>) is a research project of the
* <e-UCM> research group.
*
* Copyright 2005-2010 <e-UCM> research group.
*
* You can access a list of all the contributors to eAdventure at:
* http://e-adventure.e-ucm.es/contributors
*
* <e-UCM> is a research group of the Department of Software Engineering
* and Artificial Intelligence at the Complutense University of Madrid
* (School of Computer Science).
*
* C Profesor Jose Garcia Santesmases sn,
* 28040 Madrid (Madrid), Spain.
*
* For more info please visit: <http://e-adventure.e-ucm.es> or
* <http://www.e-ucm.es>
*
* ****************************************************************************
*
* This file is part of eAdventure, version 2.0
*
* eAdventure is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* eAdventure is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with eAdventure. If not, see <http://www.gnu.org/licenses/>.
*/
package ead.importer.auxiliar;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import ead.importer.EAdElementImporter;
import ead.importer.GenericImporter;
import ead.importer.interfaces.EAdElementFactory;
import es.eucm.ead.model.assets.drawable.basics.Image;
import es.eucm.ead.model.elements.Chapter;
import es.eucm.ead.model.elements.huds.MouseHud;
import es.eucm.ead.model.elements.operations.ElementField;
import es.eucm.ead.model.elements.scenes.SceneElementDef;
import es.eucm.ead.model.params.variables.VarDef;
import es.eucm.eadventure.common.data.adventure.AdventureData;
import es.eucm.eadventure.common.data.adventure.DescriptorData;
import es.eucm.eadventure.common.data.chapter.conditions.Conditions;
import es.eucm.eadventure.common.data.chapter.conversation.Conversation;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Singleton
public class EAdElementFactoryImpl implements EAdElementFactory {
private Map<String, Map<String, EAdElement>> elements;
private Map<String, Map<String, ElementField>> chapterVars;
private Map<String, Map<String, Condition>> chapterGlobalStates;
private List<SceneElementDef> draggableActors;
private Map<String, Image> defaultCursors;
private Map<String, Object> oldType;
private Chapter currentChapter;
private es.eucm.eadventure.common.data.chapter.Chapter currentOldChapter;
private AdventureData model;
private EAdElementImporter<Conditions, Condition> conditionImporter;
private Injector injector;
public static Map<Class<?>, Class<? extends GenericImporter<?, ?>>> importerMap = new LinkedHashMap<Class<?>, Class<? extends GenericImporter<?, ?>>>();
@Inject
public EAdElementFactoryImpl(
EAdElementImporter<Conditions, Condition> conditionImporter,
EAdElementImporter<Conversation, Effect> conversationImporter,
Injector injector) {
this.conditionImporter = conditionImporter;
draggableActors = new ArrayList<SceneElementDef>();
elements = new LinkedHashMap<String, Map<String, EAdElement>>();
chapterVars = new LinkedHashMap<String, Map<String, ElementField>>();
chapterGlobalStates = new LinkedHashMap<String, Map<String, Condition>>();
oldType = new LinkedHashMap<String, Object>();
defaultCursors = new LinkedHashMap<String, Image>();
this.injector = injector;
}
@Override
public void registerOldElement(String id, Object oldElement) {
oldType.put(id, oldElement);
}
@Override
public BasicElement getElementById(String id) {
Map<String, EAdElement> chapterElements = getChapterElements();
BasicElement element = chapterElements.get(id);
if (element == null) {
element = getElement(id, oldType.get(id));
}
return element;
}
@Override
public es.eucm.eadventure.common.data.chapter.Chapter getCurrentChapterModel() {
return null; //To change body of implemented methods use File | Settings | File Templates.
}
@SuppressWarnings("unchecked")
@Override
public <S> BasicElement getElement(String id, S oldElement) {
EAdElementImporter<S, EAdElement> importer = (EAdElementImporter<S, EAdElement>) findElementImporter(oldElement
.getClass());
BasicElement newElement = importer.init(oldElement);
getChapterElements().put(id, newElement);
newElement = importer.convert(oldElement, newElement);
return newElement;
}
public Map<String, EAdElement> getChapterElements() {
Map<String, EAdElement> chapterElements = elements.get(currentChapter
.getId());
if (chapterElements == null) {
chapterElements = new LinkedHashMap<String, EAdElement>();
elements.put(currentChapter.getId(), chapterElements);
}
return chapterElements;
}
@SuppressWarnings("unchecked")
private <S, I extends EAdElement> EAdElementImporter<S, I> findElementImporter(
Class<S> clazz) {
return (EAdElementImporter<S, I>) findGenericImporter(clazz);
}
@SuppressWarnings("unchecked")
private <S, I extends EAdElement> GenericImporter<S, I> findGenericImporter(
Class<S> clazz) {
Class<? extends GenericImporter<?, ?>> importerClass = importerMap
.get(clazz);
GenericImporter<?, ?> genericImporter = injector
.getInstance(importerClass);
return (GenericImporter<S, I>) genericImporter;
}
public void setCurrentChapterModel(Chapter chapter,
es.eucm.eadventure.common.data.chapter.Chapter oldChapter) {
this.currentChapter = chapter;
this.currentOldChapter = oldChapter;
draggableActors.clear();
}
/**
* Sets the old data model
*
* @param data
* the old data model
*/
public void setOldDataModel(AdventureData data) {
this.model = data;
}
@Override
public boolean isFirstPerson() {
return model.getPlayerMode() == DescriptorData.MODE_PLAYER_1STPERSON;
}
public ElementField getVarByOldId(String id, int type) {
Map<String, ElementField> vars = chapterVars.get(currentChapter.getId());
if (vars == null) {
vars = new LinkedHashMap<String, ElementField>();
chapterVars.put(currentChapter.getId(), vars);
}
ElementField var = vars.get(id);
if (var == null) {
if (type == es.eucm.eadventure.common.data.chapter.conditions.Condition.FLAG_CONDITION) {
VarDef<Boolean> varDef = new VarDef<Boolean>(id, Boolean.class,
Boolean.FALSE);
var = new ElementField(currentChapter,
(VarDef<Boolean>) varDef);
currentChapter.setVarInitialValue(varDef, varDef
.getInitialValue());
} else {
VarDef<Integer> varDef = new VarDef<Integer>(id, Integer.class,
0);
var = new ElementField(currentChapter,
(VarDef<Integer>) varDef);
currentChapter.setVarInitialValue(varDef, varDef
.getInitialValue());
}
vars.put(id, var);
}
return var;
}
@Override
public Condition getGlobalStateCondition(String id) {
Map<String, Condition> globalStates = chapterGlobalStates
.get(currentChapter.getId());
if (globalStates == null) {
globalStates = new LinkedHashMap<String, Condition>();
chapterGlobalStates.put(currentChapter.getId(), globalStates);
}
Condition condition = globalStates.get(id);
if (condition == null) {
condition = conditionImporter.init(currentOldChapter
.getGlobalState(id));
condition = conditionImporter.convert(currentOldChapter
.getGlobalState(id), condition);
if (condition != null)
globalStates.put(id, condition);
}
return condition;
}
@Override
public es.eucm.eadventure.common.data.chapter.Chapter getCurrentOldChapterModel() {
return currentOldChapter;
}
@Override
public void setCurrentChapterModel(
es.eucm.eadventure.common.data.chapter.Chapter chapter,
es.eucm.eadventure.common.data.chapter.Chapter oldChapter) {
//To change body of implemented methods use File | Settings | File Templates.
}
@Override
public AdventureData getOldDataModel() {
return model;
}
@Override
public void addDraggableActor(SceneElementDef actor) {
if (!draggableActors.contains(actor)) {
draggableActors.add(actor);
}
}
@Override
public boolean isDraggableActor(SceneElementDef actor) {
return draggableActors.contains(actor);
}
@Override
public void init() {
this.elements.clear();
this.chapterGlobalStates.clear();
this.chapterVars.clear();
this.currentChapter = null;
this.currentOldChapter = null;
this.defaultCursors.clear();
this.draggableActors.clear();
this.elements.clear();
this.model = null;
this.oldType.clear();
}
@Override
public String createCursor(Image image) {
//XXX Add image as bundle of mouse element
return MouseHud.DEFAULT_CURSOR;
}
@Override
public String getDefaultCursor(String cursor) {
//XXX
return MouseHud.DEFAULT_CURSOR;
}
}